@c %**start of header
@setfilename g77.info
-@set last-update 2001-06-10
+@set last-update 2001-11-14
@set copyrights-g77 1995,1996,1997,1998,1999,2000,2001
@include root.texi
@c margin. -- burley 1999-03-13 (from mew's comment in gcc.texi).
@c @finalout
+@macro gcctabopt{body}
+@code{\body\}
+@end macro
+@macro gccoptlist{body}
+@smallexample
+\body\
+@end smallexample
+@end macro
+@c Makeinfo handles the above macro OK, TeX needs manual line breaks;
+@c they get lost at some point in handling the macro. But if @macro is
+@c used here rather than @alias, it produces double line breaks.
+@iftex
+@alias gol = *
+@end iftex
+@ifnottex
+@macro gol
+@end macro
+@end ifnottex
+
@ifset INTERNALS
@ifset USING
@settitle Using and Porting GNU Fortran
@end direntry
@ifset INTERNALS
@ifset USING
-This file documents the use and the internals of the GNU Fortran (@code{g77})
+This file documents the use and the internals of the GNU Fortran (@command{g77})
compiler.
-It corresponds to the @value{which-g77} version of @code{g77}.
+It corresponds to the @value{which-g77} version of @command{g77}.
@end ifset
@end ifset
@ifclear USING
-This file documents the internals of the GNU Fortran (@code{g77}) compiler.
-It corresponds to the @value{which-g77} version of @code{g77}.
+This file documents the internals of the GNU Fortran (@command{g77}) compiler.
+It corresponds to the @value{which-g77} version of @command{g77}.
@end ifclear
@ifclear INTERNALS
-This file documents the use of the GNU Fortran (@code{g77}) compiler.
-It corresponds to the @value{which-g77} version of @code{g77}.
+This file documents the use of the GNU Fortran (@command{g77}) compiler.
+It corresponds to the @value{which-g77} version of @command{g77}.
@end ifclear
Published by the Free Software Foundation
@ifset INTERNALS
@ifset USING
-This manual documents how to run, install and port @code{g77},
+This manual documents how to run, install and port @command{g77},
as well as its new features and incompatibilities,
and how to report bugs.
-It corresponds to the @value{which-g77} version of @code{g77}.
+It corresponds to the @value{which-g77} version of @command{g77}.
@end ifset
@end ifset
@ifclear INTERNALS
-This manual documents how to run and install @code{g77},
+This manual documents how to run and install @command{g77},
as well as its new features and incompatibilities, and how to report
bugs.
-It corresponds to the @value{which-g77} version of @code{g77}.
+It corresponds to the @value{which-g77} version of @command{g77}.
@end ifclear
@ifclear USING
-This manual documents how to port @code{g77},
+This manual documents how to port @command{g77},
as well as its new features and incompatibilities,
and how to report bugs.
-It corresponds to the @value{which-g77} version of @code{g77}.
+It corresponds to the @value{which-g77} version of @command{g77}.
@end ifclear
@end ifinfo
@ifset DEVELOPMENT
@emph{Warning:} This document is still under development,
-and might not accurately reflect the @code{g77} code base
+and might not accurately reflect the @command{g77} code base
of which it is a part.
Efforts are made to keep it somewhat up-to-date,
but they are particularly concentrated
on any version of this information
-that is distributed as part of a @emph{released} @code{g77}.
+that is distributed as part of a @emph{released} @command{g77}.
In particular, while this document is intended to apply to
-the @value{which-g77} version of @code{g77},
+the @value{which-g77} version of @command{g77},
only an official @emph{release} of that version
is expected to contain documentation that is
-most consistent with the @code{g77} product in that version.
+most consistent with the @command{g77} product in that version.
@end ifset
@menu
* Funding GNU Fortran:: How to help assure continued work on GNU Fortran.
@ifset USING
* Getting Started:: Finding your way around this manual.
-* What is GNU Fortran?:: How @code{g77} fits into the universe.
+* What is GNU Fortran?:: How @command{g77} fits into the universe.
* G77 and GCC:: You can compile Fortran, C, or other programs.
-* Invoking G77:: Command options supported by @code{g77}.
-* News:: News about recent releases of @code{g77}.
-* Changes:: User-visible changes to recent releases of @code{g77}.
+* Invoking G77:: Command options supported by @command{g77}.
+* News:: News about recent releases of @command{g77}.
+* Changes:: User-visible changes to recent releases of @command{g77}.
* Language:: The GNU Fortran language.
* Compiler:: The GNU Fortran compiler.
-* Other Dialects:: Dialects of Fortran supported by @code{g77}.
-* Other Compilers:: Fortran compilers other than @code{g77}.
+* Other Dialects:: Dialects of Fortran supported by @command{g77}.
+* Other Compilers:: Fortran compilers other than @command{g77}.
* Other Languages:: Languages other than Fortran.
-* Debugging and Interfacing:: How @code{g77} generates code.
+* Debugging and Interfacing:: How @command{g77} generates code.
* Collected Fortran Wisdom:: How to avoid Trouble.
* Trouble:: If you have trouble with GNU Fortran.
* Open Questions:: Things we'd like to know.
* Service:: How to find suppliers of support for GNU Fortran.
@end ifset
@ifset INTERNALS
-* Adding Options:: Guidance on teaching @code{g77} about new options.
-* Projects:: Projects for @code{g77} internals hackers.
-* Front End:: Design and implementation of the @code{g77} front end.
+* Adding Options:: Guidance on teaching @command{g77} about new options.
+* Projects:: Projects for @command{g77} internals hackers.
+* Front End:: Design and implementation of the @command{g77} front end.
@end ifset
-* M: Diagnostics. Diagnostics produced by @code{g77}.
+* M: Diagnostics. Diagnostics produced by @command{g77}.
* Index:: Index of concepts and symbol names.
@end menu
@item
The run-time library used by GNU Fortran is a repackaged version
of the @code{libf2c} library (combined from the @code{libF77} and
-@code{libI77} libraries) provided as part of @code{f2c}, available for
+@code{libI77} libraries) provided as part of @command{f2c}, available for
free from @code{netlib} sites on the Internet.
@item
significant money and/or equipment to Craig's efforts.
@item
-The following individuals served as alpha testers prior to @code{g77}'s
+The following individuals served as alpha testers prior to @command{g77}'s
public release. This work consisted of testing, researching, sometimes
debugging, and occasionally providing small amounts of code and fixes
-for @code{g77}, plus offering plenty of helpful advice to Craig:
+for @command{g77}, plus offering plenty of helpful advice to Craig:
@itemize @w{}
@item
@end itemize
@item
+Dave Love (@email{d.love@@dl.ac.uk})
+wrote the libU77 part of the run-time library.
+
+@item
Scott Snyder (@email{snyder@@d0sgif.fnal.gov})
provided the patch to add rudimentary support
for @code{INTEGER*1}, @code{INTEGER*2}, and
@item
Toon Moene (@email{toon@@moene.indiv.nluug.nl}) performed
some analysis of generated code as part of an overall project
-to improve @code{g77} code generation to at least be as good
-as @code{f2c} used in conjunction with @code{gcc}.
+to improve @command{g77} code generation to at least be as good
+as @command{f2c} used in conjunction with @command{gcc}.
So far, this has resulted in the three, somewhat
-experimental, options added by @code{g77} to the @code{gcc}
+experimental, options added by @command{g77} to the @command{gcc}
compiler and its back end.
(These, in turn, had made their way into the @code{egcs}
-version of the compiler, and do not exist in @code{gcc}
-version 2.8 or versions of @code{g77} based on that version
-of @code{gcc}.)
+version of the compiler, and do not exist in @command{gcc}
+version 2.8 or versions of @command{g77} based on that version
+of @command{gcc}.)
@item
John Carr (@email{jfc@@mit.edu}) wrote the alias analysis improvements.
(@email{support@@craftwork.com}) for all of their support.
@item
-Many other individuals have helped debug, test, and improve @code{g77}
+Many other individuals have helped debug, test, and improve @command{g77}
over the past several years, and undoubtedly more people
will be doing so in the future.
If you have done so, and would like
to various machines, and in some cases, coding (although major
changes planned for version 0.6 make it difficult to add manpower to this
area).
+
Email @email{@value{email-general}} to volunteer for this work.
+However, we strongly expect that there will never be a version 0.6
+of @command{g77}. Work on this compiler has stopped as of the release
+of GCC 3.1, except for bug fixing. @command{g77} will be succeeded by
+@command{g95} - see @uref{http://g95.sourceforge.net}.
+
@xref{Funding,,Funding Free Software}, for more information.
@node Getting Started
If you are new to GNU compilers, or have used only one GNU
compiler in the past and not had to delve into how it lets
-you manage various versions and configurations of @code{gcc},
+you manage various versions and configurations of @command{gcc},
you should see @ref{G77 and GCC}.
-Everyone except experienced @code{g77} users should
+Everyone except experienced @command{g77} users should
see @ref{Invoking G77}.
-If you're acquainted with previous versions of @code{g77},
+If you're acquainted with previous versions of @command{g77},
you should see @ref{News,,News About GNU Fortran}.
-Further, if you've actually used previous versions of @code{g77},
+Further, if you've actually used previous versions of @command{g77},
especially if you've written or modified Fortran code to
-be compiled by previous versions of @code{g77}, you
+be compiled by previous versions of @command{g77}, you
should see @ref{Changes}.
If you intend to write or otherwise compile code that is
see @ref{Collected Fortran Wisdom},
and see @ref{Trouble}.
You might also find that the problems you are encountering
-are bugs in @code{g77}---see @ref{Bugs}, for information on
+are bugs in @command{g77}---see @ref{Bugs}, for information on
reporting them, after reading the other material.
-If you need further help with @code{g77}, or with
+If you need further help with @command{g77}, or with
freely redistributable software in general,
see @ref{Service}.
-If you would like to help the @code{g77} project,
+If you would like to help the @command{g77} project,
see @ref{Funding GNU Fortran}, for information on
helping financially, and see @ref{Projects}, for information
on helping in other ways.
If you're generally curious about the future of
-@code{g77}, see @ref{Projects}.
+@command{g77}, see @ref{Projects}.
If you're curious about its past,
see @ref{Contributors},
and see @ref{Funding GNU Fortran}.
-To see a few of the questions maintainers of @code{g77} have,
+To see a few of the questions maintainers of @command{g77} have,
and that you might be able to answer,
see @ref{Open Questions}.
@cindex concepts, basic
@cindex basic concepts
-GNU Fortran, or @code{g77}, is designed initially as a free replacement
+GNU Fortran, or @command{g77}, is designed initially as a free replacement
for, or alternative to, the UNIX @code{f77} command.
-(Similarly, @code{gcc} is designed as a replacement
+(Similarly, @command{gcc} is designed as a replacement
for the UNIX @code{cc} command.)
-@code{g77} also is designed to fit in well with the other
+@command{g77} also is designed to fit in well with the other
fine GNU compilers and tools.
Sometimes these design goals conflict---in such cases, resolution
sections of this manual.
@cindex compilers
-As compilers, @code{g77}, @code{gcc}, and @code{f77}
+As compilers, @command{g77}, @command{gcc}, and @code{f77}
share the following characteristics:
@itemize @bullet
(Linking often is thought of as a separate
step, because it can be directly invoked via the
@code{ld} command.
-However, the @code{g77} and @code{gcc}
+However, the @command{g77} and @command{gcc}
commands, as with most compiler commands, automatically
perform the linking step by calling on @code{ld}
directly, unless asked to not do so by the user.)
the generated machine code run faster, and so on.
@cindex components of g77
-@cindex @code{g77}, components of
-@code{g77} consists of several components:
+@cindex @command{g77}, components of
+@command{g77} consists of several components:
-@cindex @code{gcc}, command
-@cindex commands, @code{gcc}
+@cindex @command{gcc}, command
+@cindex commands, @command{gcc}
@itemize @bullet
@item
-A modified version of the @code{gcc} command, which also might be
+A modified version of the @command{gcc} command, which also might be
installed as the system's @code{cc} command.
(In many cases, @code{cc} refers to the
system's ``native'' C compiler, which
might be a non-GNU compiler, or an older version
-of @code{gcc} considered more stable or that is
+of @command{gcc} considered more stable or that is
used to build the operating system kernel.)
-@cindex @code{g77}, command
-@cindex commands, @code{g77}
+@cindex @command{g77}, command
+@cindex commands, @command{g77}
@item
-The @code{g77} command itself, which also might be installed as the
+The @command{g77} command itself, which also might be installed as the
system's @code{f77} command.
@cindex libg2c library
The @code{libg2c} run-time library.
This library contains the machine code needed to support
capabilities of the Fortran language that are not directly
-provided by the machine code generated by the @code{g77}
+provided by the machine code generated by the @command{g77}
compilation phase.
-@code{libg2c} is just the unique name @code{g77} gives
+@code{libg2c} is just the unique name @command{g77} gives
to its version of @code{libf2c} to distinguish it from
-any copy of @code{libf2c} installed from @code{f2c}
-(or versions of @code{g77} that built @code{libf2c} under
+any copy of @code{libf2c} installed from @command{f2c}
+(or versions of @command{g77} that built @code{libf2c} under
that same name)
on the system.
to an @dfn{assembler}, usually named @code{as}.
@end itemize
-@code{gcc} is often thought of as ``the C compiler'' only,
+@command{gcc} is often thought of as ``the C compiler'' only,
but it does more than that.
Based on command-line options and the names given for files
-on the command line, @code{gcc} determines which actions to perform, including
+on the command line, @command{gcc} determines which actions to perform, including
preprocessing, compiling (in a variety of possible languages), assembling,
and linking.
@cindex driver, gcc command as
-@cindex @code{gcc}, command as driver
+@cindex @command{gcc}, command as driver
@cindex executable file
@cindex files, executable
@cindex cc1 program
@cindex programs, cc1plus
As another example, the command @samp{gcc foo.cc} would do much the same as
@samp{gcc foo.c}, but instead of using the C compiler named @code{cc1},
-@code{gcc} would use the C++ compiler (named @code{cc1plus}).
+@command{gcc} would use the C++ compiler (named @code{cc1plus}).
@cindex @code{f771}, program
@cindex programs, @code{f771}
-In a GNU Fortran installation, @code{gcc} recognizes Fortran source
+In a GNU Fortran installation, @command{gcc} recognizes Fortran source
files by name just like it does C and C++ source files.
It knows to use the Fortran compiler named @code{f771}, instead of
@code{cc1} or @code{cc1plus}, to compile Fortran files.
-@cindex @code{gcc}, not recognizing Fortran source
+@cindex @command{gcc}, not recognizing Fortran source
@cindex unrecognized file format
@cindex file format not recognized
-Non-Fortran-related operation of @code{gcc} is generally
-unaffected by installing the GNU Fortran version of @code{gcc}.
-However, without the installed version of @code{gcc} being the
-GNU Fortran version, @code{gcc} will not be able to compile
-and link Fortran programs---and since @code{g77} uses @code{gcc}
-to do most of the actual work, neither will @code{g77}!
-
-@cindex @code{g77}, command
-@cindex commands, @code{g77}
-The @code{g77} command is essentially just a front-end for
-the @code{gcc} command.
-Fortran users will normally use @code{g77} instead of @code{gcc},
-because @code{g77}
+Non-Fortran-related operation of @command{gcc} is generally
+unaffected by installing the GNU Fortran version of @command{gcc}.
+However, without the installed version of @command{gcc} being the
+GNU Fortran version, @command{gcc} will not be able to compile
+and link Fortran programs---and since @command{g77} uses @command{gcc}
+to do most of the actual work, neither will @command{g77}!
+
+@cindex @command{g77}, command
+@cindex commands, @command{g77}
+The @command{g77} command is essentially just a front-end for
+the @command{gcc} command.
+Fortran users will normally use @command{g77} instead of @command{gcc},
+because @command{g77}
knows how to specify the libraries needed to link with Fortran programs
(@code{libg2c} and @code{lm}).
-@code{g77} can still compile and link programs and
-source files written in other languages, just like @code{gcc}.
+@command{g77} can still compile and link programs and
+source files written in other languages, just like @command{gcc}.
@cindex printing version information
@cindex version information, printing
complex arithmetic.)
In the output of this command, the line beginning @samp{GNU Fortran Front
End} identifies the version number of GNU Fortran; immediately
-preceding that line is a line identifying the version of @code{gcc}
-with which that version of @code{g77} was built.
+preceding that line is a line identifying the version of @command{gcc}
+with which that version of @command{g77} was built.
@cindex libf2c library
@cindex libraries, libf2c
@cindex in-line code
@cindex code, in-line
-For example, while code generated by @code{g77} is likely
+For example, while code generated by @command{g77} is likely
to do additions, subtractions, and multiplications @dfn{in line}---in
the actual compiled code---it is not likely to do trigonometric
functions this way.
Instead, operations like trigonometric
functions are compiled by the @code{f771} compiler
-(invoked by @code{g77} when compiling Fortran code) into machine
+(invoked by @command{g77} when compiling Fortran code) into machine
code that, when run, calls on functions in @code{libg2c}, so
@code{libg2c} must be linked with almost every useful program
having any component compiled by GNU Fortran.
-(As mentioned above, the @code{g77} command takes
+(As mentioned above, the @command{g77} command takes
care of all this for you.)
The @code{f771} program represents most of what is unique to GNU Fortran.
While much of the @code{libg2c} component comes from
-the @code{libf2c} component of @code{f2c},
+the @code{libf2c} component of @command{f2c},
a free Fortran-to-C converter distributed by Bellcore (AT&T),
plus @code{libU77}, provided by Dave Love,
-and the @code{g77} command is just a small front-end to @code{gcc},
+and the @command{g77} command is just a small front-end to @command{gcc},
@code{f771} is a combination of two rather
large chunks of code.
@cindex GNU Back End (GBE)
@cindex GBE
-@cindex @code{gcc}, back end
+@cindex @command{gcc}, back end
@cindex back end, gcc
@cindex code generator
One chunk is the so-called @dfn{GNU Back End}, or GBE,
@cindex GNU Fortran Front End (FFE)
@cindex FFE
-@cindex @code{g77}, front end
-@cindex front end, @code{g77}
+@cindex @command{g77}, front end
+@cindex front end, @command{g77}
The other chunk of @code{f771} is the
majority of what is unique about GNU Fortran---the code that knows how
to interpret Fortran programs to determine what they are intending to
compilers are similar.
For example, diagnostics (error messages and
warnings) are similar in appearance; command-line
-options like @samp{-Wall} have generally similar effects; and the quality
+options like @option{-Wall} have generally similar effects; and the quality
of generated code (in terms of speed and size) is roughly similar
(since that work is done by the shared GBE).
@cindex compiling programs
@cindex programs, compiling
-@cindex @code{gcc}, command
-@cindex commands, @code{gcc}
-A GNU Fortran installation includes a modified version of the @code{gcc}
+@cindex @command{gcc}, command
+@cindex commands, @command{gcc}
+A GNU Fortran installation includes a modified version of the @command{gcc}
command.
-In a non-Fortran installation, @code{gcc} recognizes C, C++,
+In a non-Fortran installation, @command{gcc} recognizes C, C++,
and Objective-C source files.
-In a GNU Fortran installation, @code{gcc} also recognizes Fortran source
+In a GNU Fortran installation, @command{gcc} also recognizes Fortran source
files and accepts Fortran-specific command-line options, plus some
command-line options that are designed to cater to Fortran users
but apply to other languages as well.
@xref{G++ and GCC,,Compile C; C++; or Objective-C,gcc,Using and Porting GNU CC},
for information on the way different languages are handled
-by the GNU CC compiler (@code{gcc}).
+by the GNU CC compiler (@command{gcc}).
-@cindex @code{g77}, command
-@cindex commands, @code{g77}
-Also provided as part of GNU Fortran is the @code{g77} command.
-The @code{g77} command is designed to make compiling and linking Fortran
-programs somewhat easier than when using the @code{gcc} command for
+@cindex @command{g77}, command
+@cindex commands, @command{g77}
+Also provided as part of GNU Fortran is the @command{g77} command.
+The @command{g77} command is designed to make compiling and linking Fortran
+programs somewhat easier than when using the @command{gcc} command for
these tasks.
It does this by analyzing the command line somewhat and changing it
-appropriately before submitting it to the @code{gcc} command.
+appropriately before submitting it to the @command{gcc} command.
@cindex -v option
-@cindex @code{g77} options, -v
+@cindex @command{g77} options, -v
@cindex options, -v
-Use the @samp{-v} option with @code{g77}
+Use the @option{-v} option with @command{g77}
to see what is going on---the first line of output is the invocation
-of the @code{gcc} command.
+of the @command{gcc} command.
@include invoke.texi
or as monolithic text at
@uref{http://www.fortran.com/fortran/F77_std/f77_std.html}.
It offers some extensions that are popular among users
-of UNIX @code{f77} and @code{f2c} compilers, some that
+of UNIX @code{f77} and @command{f2c} compilers, some that
are popular among users of other compilers (such as Digital
products), some that are popular among users of the
newer Fortran 90 standard, and some that are introduced
@uref{http://www.fortran.com/fortran/Books/}. There is a `cooperative
net project', @cite{User Notes on Fortran Programming} at
@uref{ftp://vms.huji.ac.il/fortran/} and mirrors elsewhere; some of this
-material might not apply specifically to @code{g77}.)
+material might not apply specifically to @command{g77}.)
Part of what defines a particular implementation of a Fortran
-system, such as @code{g77}, is the particular characteristics
+system, such as @command{g77}, is the particular characteristics
of how it supports types, constants, and so on.
Much of this is left up to the implementation by the various
Fortran standards and accepted practice in the industry.
Much of the material is organized along the same lines
as the ANSI FORTRAN 77 standard itself.
-@xref{Other Dialects}, for information on features @code{g77} supports
+@xref{Other Dialects}, for information on features @command{g77} supports
that are not part of the GNU Fortran language.
@emph{Note}: This portion of the documentation definitely needs a lot
language is to promote wide portability of GNU Fortran programs.
GNU Fortran is an evolving language, due to the
-fact that @code{g77} itself is in beta test.
+fact that @command{g77} itself is in beta test.
Some current features of the language might later
-be redefined as dialects of Fortran supported by @code{g77}
-when better ways to express these features are added to @code{g77},
+be redefined as dialects of Fortran supported by @command{g77}
+when better ways to express these features are added to @command{g77},
for example.
Such features would still be supported by
-@code{g77}, but would be available only when
+@command{g77}, but would be available only when
one or more command-line options were used.
The GNU Fortran @emph{language} is distinct from the
-GNU Fortran @emph{compilation system} (@code{g77}).
+GNU Fortran @emph{compilation system} (@command{g77}).
-For example, @code{g77} supports various dialects of
+For example, @command{g77} supports various dialects of
Fortran---in a sense, these are languages other than
GNU Fortran---though its primary
purpose is to support the GNU Fortran language, which also is
to do so.
Currently, the GNU Fortran language is a fairly fuzzy object.
-It represents something of a cross between what @code{g77} accepts
+It represents something of a cross between what @command{g77} accepts
when compiling using the prevailing defaults and what this
document describes as being part of the language.
-Future versions of @code{g77} are expected to clarify the
+Future versions of @command{g77} are expected to clarify the
definition of the language in the documentation.
Often, this will mean adding new features to the language, in the form
-of both new documentation and new support in @code{g77}.
+of both new documentation and new support in @command{g77}.
However, it might occasionally mean removing a feature
from the language itself to ``dialect'' status.
In such a case, the documentation would be adjusted
-to reflect the change, and @code{g77} itself would likely be changed
+to reflect the change, and @command{g77} itself would likely be changed
to require one or more command-line options to continue supporting
the feature.
same behaviors from it, regardless of the kind of system they are using
at any particular time.
-This approach constrains the solutions @code{g77} can use to resolve
+This approach constrains the solutions @command{g77} can use to resolve
conflicts between various camps of Fortran users.
If these two camps disagree about what a particular construct should
-mean, @code{g77} cannot simply be changed to treat that particular construct as
+mean, @command{g77} cannot simply be changed to treat that particular construct as
having one meaning without comment (such as a warning), lest the users
expecting it to have the other meaning are unpleasantly surprised that
their code misbehaves when executed.
an excellent (and still somewhat unresolved) example of this kind of
controversy.
@xref{Backslash in Constants}.
-Other examples are likely to arise in the future, as @code{g77} developers
+Other examples are likely to arise in the future, as @command{g77} developers
strive to improve its ability to accept an ever-wider variety of existing
Fortran code without requiring significant modifications to said code.
Development of GNU Fortran is further constrained by the desire
to avoid requiring programmers to change their code.
This is important because it allows programmers, administrators,
-and others to more faithfully evaluate and validate @code{g77}
+and others to more faithfully evaluate and validate @command{g77}
(as an overall product and as new versions are distributed)
without having to support multiple versions of their programs
so that they continue to work the same way on their existing
systems (non-GNU perhaps, but possibly also earlier versions
-of @code{g77}).
+of @command{g77}).
@node Standard Support
@section ANSI FORTRAN 77 Standard Support
@cindex FORTRAN 77 compatibility
GNU Fortran supports ANSI FORTRAN 77 with the following caveats.
-In summary, the only ANSI FORTRAN 77 features @code{g77} doesn't
+In summary, the only ANSI FORTRAN 77 features @command{g77} doesn't
support are those that are probably rarely used in actual code,
some of which are explicitly disallowed by the Fortran 90 standard.
@node No Passing External Assumed-length
@subsection No Passing External Assumed-length
-@code{g77} disallows passing of an external procedure
+@command{g77} disallows passing of an external procedure
as an actual argument if the procedure's
type is declared @code{CHARACTER*(*)}. For example:
@node No Passing Dummy Assumed-length
@subsection No Passing Dummy Assumed-length
-@code{g77} disallows passing of a dummy procedure
+@command{g77} disallows passing of a dummy procedure
as an actual argument if the procedure's
type is declared @code{CHARACTER*(*)}.
The @code{DO} variable for an implied-@code{DO} construct in a
@code{DATA} statement may not be used as the @code{DO} variable
for an outer implied-@code{DO} construct. For example, this
-fragment is disallowed by @code{g77}:
+fragment is disallowed by @command{g77}:
@smallexample
DATA ((A(I, I), I= 1, 10), I= 1, 10) /@dots{}/
An array element initializer in an implied-@code{DO} construct in a
@code{DATA} statement must contain at least one reference to the @code{DO}
variables of each outer implied-@code{DO} construct. For example,
-this fragment is disallowed by @code{g77}:
+this fragment is disallowed by @command{g77}:
@smallexample
DATA (A, I= 1, 1) /1./
@noindent
This also is disallowed by Fortran 90, as FORTRAN 77's more permissive
requirements offer no additional capabilities.
-However, @code{g77} doesn't necessarily diagnose all cases
+However, @command{g77} doesn't necessarily diagnose all cases
where this requirement is not met.
Note that it is @emph{very} unlikely that any production Fortran code
conforming implementations to diagnose cases where programs do
not conform to the language.
-However, @code{g77} as a compiler is being developed in a way that
+However, @command{g77} as a compiler is being developed in a way that
is intended to enable it to diagnose such cases in an easy-to-understand
manner.
A program that conforms to the GNU Fortran language should, when
-compiled, linked, and executed using a properly installed @code{g77}
+compiled, linked, and executed using a properly installed @command{g77}
system, perform as described by the GNU Fortran language definition.
Reasons for different behavior include, among others:
Bugs in the program.
@item
-Bug in @code{g77}.
+Bug in @command{g77}.
@item
Bugs in the system.
@end itemize
Despite these ``loopholes'', the availability of a clear specification
-of the language of programs submitted to @code{g77}, as this document
+of the language of programs submitted to @command{g77}, as this document
is intended to provide, is considered an important aspect of providing
a robust, clean, predictable Fortran implementation.
The definition of the GNU Fortran language, while having no special
legal status, can therefore be viewed as a sort of contract, or agreement.
This agreement says, in essence, ``if you write a program in this language,
-and run it in an environment (such as a @code{g77} system) that supports
+and run it in an environment (such as a @command{g77} system) that supports
this language, the program should behave in a largely predictable way''.
@node Notation Used
only if @samp{VALIDP} is @code{.TRUE.}, while others might
assume its execution is unconditional.
-(At present, @code{g77} does not diagnose code that
+(At present, @command{g77} does not diagnose code that
violates this restriction.)
@end itemize
The meaning and interpretation of @var{filename} depends on the
implementation, but typically is a filename.
-(@code{g77} treats it as a filename that it searches for
+(@command{g77} treats it as a filename that it searches for
in the current directory and/or directories specified
-via the @samp{-I} command-line option.)
+via the @option{-I} command-line option.)
The effect of the @code{INCLUDE} directive is as if the
included text directly replaced the directive in the source
might not work the same way on all GNU Fortran implementations.
Use of @samp{KIND=} makes this document more concise because
-@code{g77} is able to define values for @samp{KIND=} that
+@command{g77} is able to define values for @samp{KIND=} that
have the same meanings on all systems, due to the way the
Fortran 90 standard specifies these values are to be used.
However, use of @samp{KIND=} is @emph{not} generally recommended
when writing portable code (unless, for example, the code is
-going to be compiled only via @code{g77}, which is a widely
+going to be compiled only via @command{g77}, which is a widely
ported compiler).
GNU Fortran does not yet have adequate language constructs to
permit use of @samp{KIND=} in a fashion that would make the
to suit each particular implementation to which the program
is ported.
(These types generally won't need to be adjusted for ports of
-@code{g77}.)
+@command{g77}.)
Further details regarding GNU Fortran data types and constants
are provided below.
Further, the GNU Fortran language requires no particular values
for @var{n} to be supported by an implementation via the @samp{*@var{n}}
notation.
-@code{g77} supports @code{INTEGER*1} (as @code{INTEGER(KIND=3)})
+@command{g77} supports @code{INTEGER*1} (as @code{INTEGER(KIND=3)})
on all systems, for example,
-but not all implementations are required to do so, and @code{g77}
+but not all implementations are required to do so, and @command{g77}
is known to not support @code{REAL*1} on most (or all) systems.
As a result, except for @var{generic-type} of @code{CHARACTER},
into their code.
Future versions of the GNU Fortran language will offer
facilities that will make the writing of code portable
-to @code{g77} @emph{and} Fortran 90 implementations simpler.
+to @command{g77} @emph{and} Fortran 90 implementations simpler.
However, writing code that ports to existing FORTRAN 77
implementations depends on avoiding the @samp{KIND=} construct.
@end table
Note that these are @emph{proposed} correspondences and might change
-in future versions of @code{g77}---avoid writing code depending
-on them while @code{g77}, and therefore the GNU Fortran language
+in future versions of @command{g77}---avoid writing code depending
+on them while @command{g77}, and therefore the GNU Fortran language
it defines, is in beta testing.
Values not specified in the above list are reserved to
A prefix-radix constant, such as @samp{Z'ABCD'}, can optionally be
treated as typeless. @xref{Fortran Dialect Options,, Options
Controlling Fortran Dialect}, for information on the
-@samp{-ftypeless-boz} option.
+@option{-ftypeless-boz} option.
Typeless constants have values that depend on the context in which
they are used.
to predict whether it will continue to work when a program
(that works using this unsafe behavior)
is recompiled using different command-line options or
-a different version of @code{g77}.
+a different version of @command{g77}.
Generally, @code{%LOC()} is safe when used as an argument
to a procedure that makes use of the value of the corresponding
such use is restricted to referencing (reading) the value
of the argument to @code{%LOC()}.
-@emph{Implementation Note:} Currently, @code{g77} passes
+@emph{Implementation Note:} Currently, @command{g77} passes
arguments (those not passed using a construct such as @code{%VAL()})
by reference or descriptor, depending on the type of
the actual argument.
However, @samp{CALL FOO(%VAL(%LOC(I)))} emphatically means
``pass, by value, the address of @samp{I} in memory''.
While @samp{CALL FOO(I)} might use that same approach in a
-particular version of @code{g77}, another version or compiler
+particular version of @command{g77}, another version or compiler
might choose a different implementation, such as copy-in/copy-out,
to effect the desired behavior---and which will therefore not
necessarily compile to the same code as would
using the same version or compiler.
@xref{Debugging and Interfacing}, for detailed information on
-how this particular version of @code{g77} implements various
+how this particular version of @command{g77} implements various
constructs.
@node Specification Statements
The @code{NAMELIST} statement, and related I/O constructs, are
supported by the GNU Fortran language in essentially the same
-way as they are by @code{f2c}.
+way as they are by @command{f2c}.
This follows Fortran 90 with the restriction that on @code{NAMELIST}
input, subscripts must have the form
It is expected that this use of @code{END DO} will be removed from
the GNU Fortran language in the future, though it is likely that
-it will long be supported by @code{g77} as a dialect form.
+it will long be supported by @command{g77} as a dialect form.
@end itemize
@node Construct Names
portable, and should be thoroughly tested each time they
are rebuilt using a new compiler or version of a compiler.
-@emph{Implementation Note:} Currently, @code{g77} passes
+@emph{Implementation Note:} Currently, @command{g77} passes
all arguments either by reference or by descriptor.
Thus, use of @code{%VAL()} tends to be restricted to cases
@xref{Procedures,,Procedures (SUBROUTINE and FUNCTION)},
for detailed information on
-how this particular version of @code{g77} passes arguments
+how this particular version of @command{g77} passes arguments
to procedures.
@node %REF()
the argument, @var{arg}.
(For example, a copy-in/copy-out implementation.)
-@emph{Implementation Note:} Currently, @code{g77} passes
+@emph{Implementation Note:} Currently, @command{g77} passes
all arguments
(other than variables and arrays of type @code{CHARACTER})
by reference.
-Future versions of, or dialects supported by, @code{g77} might
+Future versions of, or dialects supported by, @command{g77} might
not pass @code{CHARACTER} functions by reference.
Thus, use of @code{%REF()} tends to be restricted to cases
used for Fortran @code{CHARACTER} arguments.
@xref{Procedures,,Procedures (SUBROUTINE and FUNCTION)}, for detailed information on
-how this particular version of @code{g77} passes arguments
+how this particular version of @command{g77} passes arguments
to procedures.
@node %DESCR()
pass-by-reference semantics without passing a pointer to
the argument, @var{arg}.
(For example, a copy-in/copy-out implementation.)
-And, future versions of @code{g77} might change the
+And, future versions of @command{g77} might change the
way descriptors are implemented, such as passing a
single argument pointing to a record containing the
pointer/length information instead of passing that same
information via two arguments as it currently does.
-@emph{Implementation Note:} Currently, @code{g77} passes
+@emph{Implementation Note:} Currently, @command{g77} passes
all variables and arrays of type @code{CHARACTER}
by descriptor.
-Future versions of, or dialects supported by, @code{g77} might
+Future versions of, or dialects supported by, @command{g77} might
pass @code{CHARACTER} functions by descriptor as well.
Thus, use of @code{%DESCR()} tends to be restricted to cases
used for Fortran @code{CHARACTER} arguments.
@xref{Procedures,,Procedures (SUBROUTINE and FUNCTION)}, for detailed information on
-how this particular version of @code{g77} passes arguments
+how this particular version of @command{g77} passes arguments
to procedures.
@node Generics and Specifics
they happened to have the exact same effect in that language
(due to having only one @code{COMPLEX} type).
-@emph{Note:} When @samp{-ff90} is in effect,
-@code{g77} treats @samp{REAL(@var{expr})}, where @var{expr} is of
+@emph{Note:} When @option{-ff90} is in effect,
+@command{g77} treats @samp{REAL(@var{expr})}, where @var{expr} is of
type @code{COMPLEX}, as @samp{REALPART(@var{expr})},
whereas with @samp{-fugly-complex -fno-f90} in effect, it is
treated as @samp{REAL(REALPART(@var{expr}))}.
an extra argument used to specify the desired kind of complex
result.
However, this solution is somewhat awkward to use, and
-@code{g77} currently does not support it.
+@command{g77} currently does not support it.
The GNU Fortran language provides a simple way to build a complex
value out of two numbers, with the precise type of the value
@code{ISHFTC}, @code{MVBITS}, and @code{NOT}.
@node f77/f2c Intrinsics
-@subsection @code{f77}/@code{f2c} Intrinsics
+@subsection @code{f77}/@command{f2c} Intrinsics
The bit-manipulation intrinsics supported by traditional
-@code{f77} and by @code{f2c} are available in the GNU Fortran language.
+@code{f77} and by @command{f2c} are available in the GNU Fortran language.
These include @code{AND}, @code{LSHIFT}, @code{OR}, @code{RSHIFT},
and @code{XOR}.
they are documented elsewhere.
@xref{Characters Lines Sequence,,@asis{Characters, Lines, and Execution Sequence}},
for information on additional fixed source form lexical issues.
-@cindex @samp{-ffree-form}
+@cindex @option{-ffree-form}
Further, the free source form is supported through the
-@samp{-ffree-form} option.
-@cindex @samp{-ff90}
-Other Fortran 90 features can be turned on by the @samp{-ff90} option;
+@option{-ffree-form} option.
+@cindex @option{-ff90}
+Other Fortran 90 features can be turned on by the @option{-ff90} option;
see @ref{Fortran 90}.
For information on the Fortran 90 intrinsics available,
see @ref{Table of Intrinsic Functions}.
GNU Fortran supports a variety of features that are not
considered part of the GNU Fortran language itself, but
are representative of various dialects of Fortran that
-@code{g77} supports in whole or in part.
+@command{g77} supports in whole or in part.
Any of the features listed below might be disallowed by
-@code{g77} unless some command-line option is specified.
+@command{g77} unless some command-line option is specified.
Currently, some of the features are accepted using the
-default invocation of @code{g77}, but that might change
+default invocation of @command{g77}, but that might change
in the future.
@emph{Note: This portion of the documentation definitely needs a lot
are explicitly left to the implementation by the published Fortran
standards.
GNU Fortran currently tries to be somewhat like a few popular compilers
-(@code{f2c}, Digital (``DEC'') Fortran, and so on), though a cleaner default
+(@command{f2c}, Digital (``DEC'') Fortran, and so on), though a cleaner default
definition along with more
flexibility offered by command-line options is likely to be offered
in version 0.6.
-This section describes how @code{g77} interprets source lines.
+This section describes how @command{g77} interprets source lines.
@menu
* Carriage Returns:: Carriage returns ignored.
@cindex carriage returns
Carriage returns (@samp{\r}) in source lines are ignored.
-This is somewhat different from @code{f2c}, which seems to treat them as
+This is somewhat different from @command{f2c}, which seems to treat them as
spaces outside character/Hollerith constants, and encodes them as @samp{\r}
inside such constants.
A source line with a @key{TAB} character anywhere in it is treated as
entirely significant---however long it is---instead of ending in
column 72 (for fixed-form source) or 132 (for free-form source).
-This also is different from @code{f2c}, which encodes tabs as
+This also is different from @command{f2c}, which encodes tabs as
@samp{\t} (the ASCII @key{TAB} character) inside character
and Hollerith constants, but nevertheless seems to treat the column
position as if it had been affected by the canonical tab positioning.
-@code{g77} effectively
+@command{g77} effectively
translates tabs to the appropriate number of spaces (a la the default
for the UNIX @code{expand} command) before doing any other processing, other
than (currently) noting whether a tab was found on a line and using this
basis of Fortran and the way the Fortran standard expressed fixed
source form).
-@code{g77} might someday offer an option to warn about cases where differences
+@command{g77} might someday offer an option to warn about cases where differences
might be seen as a result of this treatment, and perhaps an option to
specify the alternate behavior as well.
Note that this padding cannot apply to lines that are effectively of
infinite length---such lines are specified using command-line options
-like @samp{-ffixed-line-length-none}, for example.
+like @option{-ffixed-line-length-none}, for example.
@node Long Lines
@subsection Long Lines
Source lines longer than the applicable length are truncated to that
length.
-Currently, @code{g77} does not warn if the truncated characters are
+Currently, @command{g77} does not warn if the truncated characters are
not spaces, to accommodate existing code written for systems that
treated truncated text as commentary (especially in columns 73 through 80).
@xref{Fortran Dialect Options,,Options Controlling Fortran Dialect},
-for information on the @samp{-ffixed-line-length-@var{n}} option,
+for information on the @option{-ffixed-line-length-@var{n}} option,
which can be used to set the line length applicable to fixed-form
source files.
@cindex continuation line, ampersand
A @samp{&} in column 1 of fixed-form source denotes an arbitrary-length
-continuation line, imitating the behavior of @code{f2c}.
+continuation line, imitating the behavior of @command{f2c}.
@node Trailing Comment
@section Trailing Comment
@cindex /*
@cindex !
@cindex exclamation point
-@code{g77} supports use of @samp{/*} to start a trailing
+@command{g77} supports use of @samp{/*} to start a trailing
comment.
In the GNU Fortran language, @samp{!} is used for this purpose.
When treated as a normal line, such a line is treated as if
the first character was @key{SPC} (space).
-(Currently, @code{g77} provides no means for treating debug
+(Currently, @command{g77} provides no means for treating debug
lines as normal lines.)
@node Dollar Signs
@cindex $
Dollar signs (@samp{$}) are allowed in symbol names (after the first character)
-when the @samp{-fdollar-ok} option is specified.
+when the @option{-fdollar-ok} option is specified.
@node Case Sensitivity
@section Case Sensitivity
@end itemize
@end itemize
-Note 1: @code{g77} eventually will support @code{NAMELIST} in a manner that is
+Note 1: @command{g77} eventually will support @code{NAMELIST} in a manner that is
consistent with these source switches---in the sense that input will be
expected to meet the same requirements as source code in terms
of matching symbol names and keywords (for the exponent letters).
Number 22 is the ``strict'' ANSI FORTRAN 77 model wherein all input
(except comments, character constants, and Hollerith strings) must
be entered in uppercase.
-Use @samp{-fcase-strict-upper} to specify this
+Use @option{-fcase-strict-upper} to specify this
combination.
Number 43 is like Number 22 except all input must be lowercase. Use
-@samp{-fcase-strict-lower} to specify this combination.
+@option{-fcase-strict-lower} to specify this combination.
Number 65 is the ``classic'' ANSI FORTRAN 77 model as implemented on many
non-UNIX machines whereby all the source is translated to uppercase.
-Use @samp{-fcase-upper} to specify this combination.
+Use @option{-fcase-upper} to specify this combination.
Number 66 is the ``canonical'' UNIX model whereby all the source is
translated to lowercase.
-Use @samp{-fcase-lower} to specify this combination.
+Use @option{-fcase-lower} to specify this combination.
There are a few nearly useless combinations:
@cindex VXT extensions
@cindex extensions, VXT
-@code{g77} supports certain constructs that
+@command{g77} supports certain constructs that
have different meanings in VXT Fortran than they
do in the GNU Fortran language.
An extension offered by a Digital Fortran product that also is
offered by several other Fortran products for different kinds of
-systems is probably going to be considered for inclusion in @code{g77}
+systems is probably going to be considered for inclusion in @command{g77}
someday, and is considered a VXT Fortran feature.
-The @samp{-fvxt} option generally specifies that, where
+The @option{-fvxt} option generally specifies that, where
the meaning of a construct is ambiguous (means one thing
in GNU Fortran and another in VXT Fortran), the VXT Fortran
meaning is to be assumed.
@cindex octal constants
@cindex constants, octal
-@code{g77} treats double-quote (@samp{"})
+@command{g77} treats double-quote (@samp{"})
as beginning an octal constant of @code{INTEGER(KIND=1)} type
-when the @samp{-fvxt} option is specified.
+when the @option{-fvxt} option is specified.
The form of this octal constant is
@example
where @var{octal-digits} is a nonempty string of characters in
the set @samp{01234567}.
-For example, the @samp{-fvxt} option permits this:
+For example, the @option{-fvxt} option permits this:
@example
PRINT *, "20
@cindex comment character
@cindex characters, comment
-@code{g77} treats an exclamation point (@samp{!}) in column 6 of
+@command{g77} treats an exclamation point (@samp{!}) in column 6 of
a fixed-form source file
as a continuation character rather than
as the beginning of a comment
(as it does in any other column)
-when the @samp{-fvxt} option is specified.
+when the @option{-fvxt} option is specified.
The following program, when run, prints a message indicating
whether it is interpreted according to GNU Fortran (and Fortran 90)
@cindex Fortran 90, compatibility
The GNU Fortran language includes a number of features that are
-part of Fortran 90, even when the @samp{-ff90} option is not specified.
-The features enabled by @samp{-ff90} are intended to be those that,
-when @samp{-ff90} is not specified, would have another
-meaning to @code{g77}---usually meaning something invalid in the
+part of Fortran 90, even when the @option{-ff90} option is not specified.
+The features enabled by @option{-ff90} are intended to be those that,
+when @option{-ff90} is not specified, would have another
+meaning to @command{g77}---usually meaning something invalid in the
GNU Fortran language.
-So, the purpose of @samp{-ff90} is not to specify whether @code{g77} is
+So, the purpose of @option{-ff90} is not to specify whether @command{g77} is
to gratuitously reject Fortran 90 constructs.
-The @samp{-pedantic} option specified with @samp{-fno-f90} is intended
+The @option{-pedantic} option specified with @option{-fno-f90} is intended
to do that, although its implementation is certainly incomplete at
this point.
-When @samp{-ff90} is specified:
+When @option{-ff90} is specified:
@itemize @bullet
@item
For example, assuming @samp{Z} is type @code{COMPLEX(KIND=2)},
@samp{REAL(Z)} would return a value of type @code{REAL(KIND=2)},
-not of type @code{REAL(KIND=1)}, since @samp{-ff90} is specified.
+not of type @code{REAL(KIND=1)}, since @option{-ff90} is specified.
@end itemize
@node Pedantic Compilation
@cindex pedantic compilation
@cindex compilation, pedantic
-The @samp{-fpedantic} command-line option specifies that @code{g77}
+The @option{-fpedantic} command-line option specifies that @command{g77}
is to warn about code that is not standard-conforming.
This is useful for finding
-some extensions @code{g77} accepts that other compilers might not accept.
-(Note that the @samp{-pedantic} and @samp{-pedantic-errors} options
-always imply @samp{-fpedantic}.)
+some extensions @command{g77} accepts that other compilers might not accept.
+(Note that the @option{-pedantic} and @option{-pedantic-errors} options
+always imply @option{-fpedantic}.)
-With @samp{-fno-f90} in force, ANSI FORTRAN 77 is used as the standard
+With @option{-fno-f90} in force, ANSI FORTRAN 77 is used as the standard
for conforming code.
-With @samp{-ff90} in force, Fortran 90 is used.
+With @option{-ff90} in force, Fortran 90 is used.
-The constructs for which @code{g77} issues diagnostics when @samp{-fpedantic}
-and @samp{-fno-f90} are in force are:
+The constructs for which @command{g77} issues diagnostics when @option{-fpedantic}
+and @option{-fno-f90} are in force are:
@itemize @bullet
@item
(In the GNU Fortran language, @samp{DATA I/1/} may be followed by @samp{INTEGER J},
but not @samp{INTEGER I}.
-The @samp{-fpedantic} option disallows both of these.)
+The @option{-fpedantic} option disallows both of these.)
@item
Semicolon as statement separator, as in:
as @samp{X*-Y}.
@end itemize
-If @samp{-fpedantic} is specified along with @samp{-ff90}, the
+If @option{-fpedantic} is specified along with @option{-ff90}, the
following constructs result in diagnostics:
@itemize @bullet
@cindex ugly features
@cindex features, ugly
-The @samp{-fugly-*} command-line options determine whether certain
+The @option{-fugly-*} command-line options determine whether certain
features supported by VAX FORTRAN and other such compilers, but considered
too ugly to be in code that can be changed to use safer and/or more
portable constructs, are accepted.
extensions that just plain look ugly in the harsh light of day.
@menu
-* Ugly Implicit Argument Conversion:: Disabled via @samp{-fno-ugly-args}.
-* Ugly Assumed-Size Arrays:: Enabled via @samp{-fugly-assumed}.
-* Ugly Null Arguments:: Enabled via @samp{-fugly-comma}.
-* Ugly Complex Part Extraction:: Enabled via @samp{-fugly-complex}.
-* Ugly Conversion of Initializers:: Disabled via @samp{-fno-ugly-init}.
-* Ugly Integer Conversions:: Enabled via @samp{-fugly-logint}.
-* Ugly Assigned Labels:: Enabled via @samp{-fugly-assign}.
+* Ugly Implicit Argument Conversion:: Disabled via @option{-fno-ugly-args}.
+* Ugly Assumed-Size Arrays:: Enabled via @option{-fugly-assumed}.
+* Ugly Null Arguments:: Enabled via @option{-fugly-comma}.
+* Ugly Complex Part Extraction:: Enabled via @option{-fugly-complex}.
+* Ugly Conversion of Initializers:: Disabled via @option{-fno-ugly-init}.
+* Ugly Integer Conversions:: Enabled via @option{-fugly-logint}.
+* Ugly Assigned Labels:: Enabled via @option{-fugly-assign}.
@end menu
@node Ugly Implicit Argument Conversion
@cindex Hollerith constants
@cindex constants, Hollerith
-The @samp{-fno-ugly-args} option disables
+The @option{-fno-ugly-args} option disables
passing typeless and Hollerith constants as actual arguments
in procedure invocations.
For example:
@cindex assumed-size arrays
@cindex DIMENSION X(1)
-The @samp{-fugly-assumed} option enables
+The @option{-fugly-assumed} option enables
the treatment of any array with a final dimension specified as @samp{1}
as an assumed-size array, as if @samp{*} had been specified
instead.
treated if @samp{X} is listed as a dummy argument only
@emph{after} the @code{DIMENSION} statement (presumably in
an @code{ENTRY} statement).
-For example, @samp{-fugly-assumed} has no effect on the
+For example, @option{-fugly-assumed} has no effect on the
following program unit:
@example
@cindex real part
@cindex imaginary part
-The @samp{-fugly-complex} option enables
+The @option{-fugly-complex} option enables
use of the @code{REAL()} and @code{AIMAG()}
intrinsics with arguments that are
@code{COMPLEX} types other than @code{COMPLEX(KIND=1)}.
-With @samp{-ff90} in effect, these intrinsics return
+With @option{-ff90} in effect, these intrinsics return
the unconverted real and imaginary parts (respectively)
of their argument.
-With @samp{-fno-f90} in effect, these intrinsics convert
+With @option{-fno-f90} in effect, these intrinsics convert
the real and imaginary parts to @code{REAL(KIND=1)}, and return
the result of that conversion.
@noindent
is permitted even when @samp{Z} is @code{COMPLEX(KIND=2)}
-and @samp{-fno-ugly-complex} is in effect, because the
+and @option{-fno-ugly-complex} is in effect, because the
meaning is clear.
-@code{g77} enforces this restriction, unless @samp{-fugly-complex}
+@command{g77} enforces this restriction, unless @option{-fugly-complex}
is specified, in which case the appropriate interpretation is
chosen and no diagnostic is issued.
@cindex null arguments
@cindex arguments, null
-The @samp{-fugly-comma} option enables use of a single trailing comma
+The @option{-fugly-comma} option enables use of a single trailing comma
to mean ``pass an extra trailing null argument''
in a list of actual arguments to an external procedure,
and use of an empty list of arguments to such a procedure
That is, this construct changes the meaning of code that
makes no use of the construct.
-So, with @samp{-fugly-comma} in force, @samp{CALL FOO()}
+So, with @option{-fugly-comma} in force, @samp{CALL FOO()}
and @samp{I = JFUNC()} pass a single null argument, instead
of passing no arguments as required by the Fortran 77 and
90 standards.
So, in practice, there might be no difference in
the behavior of a program that does @samp{CALL FOO()}
-or @samp{I = JFUNC()} and is compiled with @samp{-fugly-comma}
+or @samp{I = JFUNC()} and is compiled with @option{-fugly-comma}
in force as compared to its behavior when compiled
-with the default, @samp{-fno-ugly-comma}, in force,
+with the default, @option{-fno-ugly-comma}, in force,
assuming @samp{FOO} and @samp{JFUNC} do not expect any
arguments to be passed.
@node Ugly Conversion of Initializers
@subsection Ugly Conversion of Initializers
-The constructs disabled by @samp{-fno-ugly-init} are:
+The constructs disabled by @option{-fno-ugly-init} are:
@itemize @bullet
@cindex Hollerith constants
type-declaration statements specifying initial values.
Here are some sample initializations that are disabled by the
-@samp{-fno-ugly-init} option:
+@option{-fno-ugly-init} option:
@example
PARAMETER (VAL='9A304FFE'X)
numeric items and vice versa (one constant per item).
Here are more sample initializations that are disabled by the
-@samp{-fno-ugly-init} option:
+@option{-fno-ugly-init} option:
@example
INTEGER IA
arguments, in these cases).
Here are sample statements that are disabled by the
-@samp{-fno-ugly-init} option:
+@option{-fno-ugly-init} option:
@example
IVAR = 4HABCD
@node Ugly Integer Conversions
@subsection Ugly Integer Conversions
-The constructs enabled via @samp{-fugly-logint} are:
+The constructs enabled via @option{-fugly-logint} are:
@itemize @bullet
@item
@cindex assigned labels
@cindex pointers
-The @samp{-fugly-assign} option forces @code{g77} to use the
+The @option{-fugly-assign} option forces @command{g77} to use the
same storage for assigned labels as it would for a normal
assignment to the same variable.
@end example
@noindent
-Normally, for portability and improved diagnostics, @code{g77}
+Normally, for portability and improved diagnostics, @command{g77}
reserves distinct storage for a ``sibling'' of @samp{I}, used
only for @code{ASSIGN} statements to that variable (along with
the corresponding assigned-@code{GOTO} and assigned-@code{FORMAT}-I/O
@end example
@noindent
-Such code doesn't work under @code{g77} unless @samp{-fugly-assign}
+Such code doesn't work under @command{g77} unless @option{-fugly-assign}
is specified on the command-line, ensuring that the value of @code{I}
-referenced in the second line is whatever value @code{g77} uses
+referenced in the second line is whatever value @command{g77} uses
to designate statement label @samp{10}, so the value may be
copied into the @samp{ISTATE} array, later retrieved into a
variable of the appropriate type (@samp{J}), and used as the target of
an assigned-@code{GOTO} statement.
@emph{Note:} To avoid subtle program bugs,
-when @samp{-fugly-assign} is specified,
-@code{g77} requires the type of variables
+when @option{-fugly-assign} is specified,
+@command{g77} requires the type of variables
specified in assigned-label contexts
@emph{must} be the same type returned by @code{%LOC()}.
On many systems, this type is effectively the same
as @code{INTEGER(KIND=1)}, while, on others, it is
effectively the same as @code{INTEGER(KIND=2)}.
-Do @emph{not} depend on @code{g77} actually writing valid pointers
+Do @emph{not} depend on @command{g77} actually writing valid pointers
to these variables, however.
-While @code{g77} currently chooses that implementation, it might
+While @command{g77} currently chooses that implementation, it might
be changed in the future.
@xref{Assigned Statement Labels,,Assigned Statement Labels (ASSIGN and GOTO)},
@node Compiler
@chapter The GNU Fortran Compiler
-The GNU Fortran compiler, @code{g77}, supports programs written
+The GNU Fortran compiler, @command{g77}, supports programs written
in the GNU Fortran language and in some other dialects of Fortran.
-Some aspects of how @code{g77} works are universal regardless
+Some aspects of how @command{g77} works are universal regardless
of dialect, and yet are not properly part of the GNU Fortran
language itself.
These are described below.
@cindex limits, compiler
@cindex compiler limits
-@code{g77}, as with GNU tools in general, imposes few arbitrary restrictions
+@command{g77}, as with GNU tools in general, imposes few arbitrary restrictions
on lengths of identifiers, number of continuation lines, number of external
symbols in a program, and so on.
@cindex limits, continuation lines
@cindex limits, lengths of names
For example, some other Fortran compiler have an option
-(such as @samp{-Nl@var{x}}) to increase the limit on the
+(such as @option{-Nl@var{x}}) to increase the limit on the
number of continuation lines.
Also, some Fortran compilation systems have an option
-(such as @samp{-Nx@var{x}}) to increase the limit on the
+(such as @option{-Nx@var{x}}) to increase the limit on the
number of external symbols.
-@code{g77}, @code{gcc}, and GNU @code{ld} (the GNU linker) have
+@command{g77}, @command{gcc}, and GNU @code{ld} (the GNU linker) have
no equivalent options, since they do not impose arbitrary
limits in these areas.
@cindex maximum number of dimensions
@cindex limits, rank
@cindex limits, array dimensions
-@code{g77} does currently limit the number of dimensions in an array
+@command{g77} does currently limit the number of dimensions in an array
to the same degree as do the Fortran standards---seven (7).
This restriction might be lifted in a future version.
@cindex wraparound
As a portable Fortran implementation,
-@code{g77} offers its users direct access to,
+@command{g77} offers its users direct access to,
and otherwise depends upon,
the underlying facilities of the system
-used to build @code{g77},
-the system on which @code{g77} itself is used to compile programs,
-and the system on which the @code{g77}-compiled program is actually run.
+used to build @command{g77},
+the system on which @command{g77} itself is used to compile programs,
+and the system on which the @command{g77}-compiled program is actually run.
(For most users, the three systems are of the same
type---combination of operating environment and hardware---often
the same physical system.)
Even when such limits might be well beyond the
possibility of being encountered on a particular system,
-the @code{g77} run-time environment
+the @command{g77} run-time environment
has certain built-in limits,
usually, but not always, stemming from intrinsics
with inherently limited interfaces.
-Currently, the @code{g77} run-time environment
+Currently, the @command{g77} run-time environment
does not generally offer a less-limiting environment
by augmenting the underlying system's own environment.
prove to be false for some particular environments.
The GNU Fortran language,
-the @code{g77} compiler and run-time environment,
-and the @code{g77} documentation
+the @command{g77} compiler and run-time environment,
+and the @command{g77} documentation
do not yet offer comprehensive portable work-arounds for such limits,
though programmers should be able to
find their own in specific instances.
@cindex Y2K compliance
@cindex Year 2000 compliance
-While the @code{g77} compiler itself is believed to
+While the @command{g77} compiler itself is believed to
be Year-2000 (Y2K) compliant,
some intrinsics are not,
and, potentially, some underlying systems are not,
@cindex G77_date_y2kbuggy_0
@cindex G77_vxtidate_y2kbuggy_0
The @code{libg2c} library
-shipped with any @code{g77} that warns
+shipped with any @command{g77} that warns
about invocation of a non-Y2K-compliant intrinsic
has renamed the @code{EXTERNAL} procedure names
of those intrinsics.
(Note that the @code{EXTERNAL} statement
is not actually required,
since the modified names are not recognized as intrinsics
-by the current version of @code{g77}.
+by the current version of @command{g77}.
But it is shown in this specific case,
for purposes of illustration.)
The renaming of @code{EXTERNAL} procedure names of these intrinsics
causes unresolved references at link time.
For example, @samp{EXTERNAL DATE; CALL DATE(STR)}
-is normally compiled by @code{g77}
+is normally compiled by @command{g77}
as, in C, @samp{date_(&str, 20);}.
This, in turn, links to the @code{date_} procedure
in the @code{libE77} portion of @code{libg2c},
named @code{G77_date_y2kbuggy_0}.
The resulting link-time error is designed, via this name,
to encourage the programmer to look up the
-index entries to this portion of the @code{g77} documentation.
+index entries to this portion of the @command{g77} documentation.
Generally, we recommend that the @code{EXTERNAL} method
of invoking procedures in @code{libg2c}
@emph{not} be used.
When used, some of the correctness checking
-normally performed by @code{g77}
+normally performed by @command{g77}
is skipped.
In particular, it is probably better to use the
non-Y2K-compliant procedures,
so anyone compiling the code
can quickly notice the potential Y2K problems
-(via the warnings printing by @code{g77})
+(via the warnings printing by @command{g77})
without having to even look at the code itself.
If there are problems linking @code{libg2c}
-to code compiled by @code{g77}
+to code compiled by @command{g77}
that involve the string @samp{y2kbug},
and these are not explained above,
that probably indicates
that a version of @code{libg2c}
-older than @code{g77}
+older than @command{g77}
is being linked to,
or that the new library is being linked
-to code compiled by an older version of @code{g77}.
+to code compiled by an older version of @command{g77}.
That's because, as of the version that warns about
non-Y2K-compliant intrinsic invocation,
-@code{g77} references the @code{libg2c} implementations
+@command{g77} references the @code{libg2c} implementations
of those intrinsics
using new names, containing the string @samp{y2kbug}.
(The new library calls it @code{G77_vxtidate_y2kbug_0}.)
The proper fix for the above problems
-is to obtain the latest release of @code{g77}
+is to obtain the latest release of @command{g77}
and related products
(including @code{libg2c})
and install them on all systems,
potential Y2K problems
than to ease the transition
of potentially non-Y2K-compliant code
-to new versions of @code{g77} and @code{libg2c}.)
+to new versions of @command{g77} and @code{libg2c}.)
@node Array Size
@subsection Array Size
@cindex limits, array size
@cindex array size
-Currently, @code{g77} uses the default @code{INTEGER} type
+Currently, @command{g77} uses the default @code{INTEGER} type
for array indexes,
which limits the sizes of single-dimension arrays
on systems offering a larger address space
than can be addressed by that type.
-(That @code{g77} puts all arrays in memory
+(That @command{g77} puts all arrays in memory
could be considered another limitation---it
could use large temporary files---but that decision
is left to the programmer as an implementation choice
@cindex multi-dimension arrays
@cindex arrays, dimensioning
Whether large multiple-dimension arrays are reliably supported
-depends mostly on the @code{gcc} back end (code generator)
-used by @code{g77}, and has not yet been fully investigated.
+depends mostly on the @command{gcc} back end (code generator)
+used by @command{g77}, and has not yet been fully investigated.
@node Character-variable Length
@subsection Character-variable Length
@cindex limits, on character-variable length
@cindex character-variable length
-Currently, @code{g77} uses the default @code{INTEGER} type
+Currently, @command{g77} uses the default @code{INTEGER} type
for the lengths of @code{CHARACTER} variables
and array elements.
This means that, for example,
a system with a 64-bit address space
and a 32-bit default @code{INTEGER} type
-does not, under @code{g77},
+does not, under @command{g77},
support a @code{CHARACTER*@var{n}} declaration
where @var{n} is greater than 2147483647.
placed on the implementation, nor is the relationship of storage sizes of
these types to the @code{CHARACTER} type specified, by the standard.)
-@code{g77} follows the above requirements, warning when compiling
+@command{g77} follows the above requirements, warning when compiling
a program requires placement of items in memory that contradict the
requirements of the target architecture.
(For example, a program can require placement of a @code{REAL(KIND=2)}
mapping of Fortran types to underlying architectural types, such
placement is prohibited by the machine definition or
the Application Binary Interface (ABI) in force for
-the configuration defined for building @code{gcc} and @code{g77}.
-@code{g77} warns about such
+the configuration defined for building @command{gcc} and @command{g77}.
+@command{g77} warns about such
situations when it encounters them.)
-@code{g77} follows consistent rules for configuring the mapping between Fortran
+@command{g77} follows consistent rules for configuring the mapping between Fortran
types, including the @samp{*@var{n}} notation, and the underlying architectural
types as accessed by a similarly-configured applicable version of the
-@code{gcc} compiler.
+@command{gcc} compiler.
These rules offer a widely portable, consistent Fortran/C
environment, although they might well conflict with the expectations of
users of Fortran compilers designed and written for particular
architectures.
These rules are based on the configuration that is in force for the
-version of @code{gcc} built in the same release as @code{g77} (and
-which was therefore used to build both the @code{g77} compiler
+version of @command{gcc} built in the same release as @command{g77} (and
+which was therefore used to build both the @command{g77} compiler
components and the @code{libg2c} run-time library):
@table @code
@cindex LOGICAL(KIND=1) type
@cindex types, LOGICAL(KIND=1)
@item LOGICAL(KIND=1)
-Same @code{gcc} type as @code{INTEGER(KIND=1)}.
+Same @command{gcc} type as @code{INTEGER(KIND=1)}.
@cindex INTEGER(KIND=2) type
@cindex types, INTEGER(KIND=2)
@cindex LOGICAL(KIND=2) type
@cindex types, LOGICAL(KIND=2)
@item LOGICAL(KIND=2)
-Same @code{gcc} type as @code{INTEGER(KIND=2)}.
+Same @command{gcc} type as @code{INTEGER(KIND=2)}.
@cindex INTEGER(KIND=3) type
@cindex types, INTEGER(KIND=3)
@item INTEGER(KIND=3)
-Same @code{gcc} type as signed @code{char}.
+Same @command{gcc} type as signed @code{char}.
@cindex LOGICAL(KIND=3) type
@cindex types, LOGICAL(KIND=3)
@item LOGICAL(KIND=3)
-Same @code{gcc} type as @code{INTEGER(KIND=3)}.
+Same @command{gcc} type as @code{INTEGER(KIND=3)}.
@cindex INTEGER(KIND=6) type
@cindex types, INTEGER(KIND=6)
@cindex LOGICAL(KIND=6) type
@cindex types, LOGICAL(KIND=6)
@item LOGICAL(KIND=6)
-Same @code{gcc} type as @code{INTEGER(KIND=6)}.
+Same @command{gcc} type as @code{INTEGER(KIND=6)}.
@cindex COMPLEX(KIND=1) type
@cindex types, COMPLEX(KIND=1)
@cindex *@var{n} notation
@item @var{numeric-type}*@var{n}
(Where @var{numeric-type} is any type other than @code{CHARACTER}.)
-Same as whatever @code{gcc} type occupies @var{n} times the storage
-space of a @code{gcc} @code{char} item.
+Same as whatever @command{gcc} type occupies @var{n} times the storage
+space of a @command{gcc} @code{char} item.
@cindex DOUBLE PRECISION type
@cindex types, DOUBLE PRECISION
@end table
Note that the above are proposed correspondences and might change
-in future versions of @code{g77}---avoid writing code depending
+in future versions of @command{g77}---avoid writing code depending
on them.
-Other types supported by @code{g77}
+Other types supported by @command{g77}
are derived from gcc types such as @code{char}, @code{short},
@code{int}, @code{long int}, @code{long long int}, @code{long double},
and so on.
-That is, whatever types @code{gcc} already supports, @code{g77} supports
+That is, whatever types @command{gcc} already supports, @command{g77} supports
now or probably will support in a future version.
The rules for the @samp{@var{numeric-type}*@var{n}} notation
apply to these types,
@cindex constants
@cindex types, constants
-@code{g77} strictly assigns types to @emph{all} constants not
+@command{g77} strictly assigns types to @emph{all} constants not
documented as ``typeless'' (typeless constants including @samp{'1'Z},
for example).
Many other Fortran compilers attempt to assign types to typed constants
code, and is not in the spirit (though it strictly follows the letter)
of the 77 and 90 standards.
-@code{g77} might offer, in a future release, explicit constructs by
+@command{g77} might offer, in a future release, explicit constructs by
which a wider variety of typeless constants may be specified, and/or
-user-requested warnings indicating places where @code{g77} might differ
+user-requested warnings indicating places where @command{g77} might differ
from how other compilers assign types to constants.
@xref{Context-Sensitive Constants}, for more information on this issue.
@node Compiler Intrinsics
@section Compiler Intrinsics
-@code{g77} offers an ever-widening set of intrinsics.
+@command{g77} offers an ever-widening set of intrinsics.
Currently these all are procedures (functions and subroutines).
Some of these intrinsics are unimplemented, but their names reserved
yet others are provided for compatibility with other dialects of
Fortran but are not part of the GNU Fortran language.
-To manage these distinctions, @code{g77} provides intrinsic @emph{groups},
+To manage these distinctions, @command{g77} provides intrinsic @emph{groups},
a facility that is simply an extension of the intrinsic groups provided
by the GNU Fortran language.
@end example
@noindent
-So, deleting a group tells @code{g77} to pretend as though the intrinsics in
-that group do not exist at all, whereas disabling it tells @code{g77} to
+So, deleting a group tells @command{g77} to pretend as though the intrinsics in
+that group do not exist at all, whereas disabling it tells @command{g77} to
recognize them as (disabled) intrinsics in intrinsic-like contexts.
Hiding a group is like enabling it, but the intrinsic must be first
Intrinsics the GNU Fortran language supports that are extensions to
the Fortran standards (77 and 90).
-@cindex @code{f2c} intrinsics group
+@cindex @command{f2c} intrinsics group
@item f2c
-Intrinsics supported by AT&T's @code{f2c} converter and/or @code{libf2c}.
+Intrinsics supported by AT&T's @command{f2c} converter and/or @code{libf2c}.
@cindex @code{f90} intrinsics group
@item f90
@cindex intrinsics, others
@cindex other intrinsics
-@code{g77} supports intrinsics other than those in the GNU Fortran
+@command{g77} supports intrinsics other than those in the GNU Fortran
language proper.
This set of intrinsics is described below.
incorrect results produced by the program (and that assumes
these errors are detected, which is not always the case).
-Normally, @code{g77} generates code that is
+Normally, @command{g77} generates code that is
object-compatible with code generated by a version of
-@code{f2c} configured (with, for example, @file{f2c.h} definitions)
-to be generally compatible with @code{g77} as built by @code{gcc}.
-(Normally, @code{f2c} will, by default, conform to the appropriate
+@command{f2c} configured (with, for example, @file{f2c.h} definitions)
+to be generally compatible with @command{g77} as built by @command{gcc}.
+(Normally, @command{f2c} will, by default, conform to the appropriate
configuration, but it is possible that older or perhaps even newer
-versions of @code{f2c}, or versions having certain configuration changes
-to @code{f2c} internals, will produce object files that are
-incompatible with @code{g77}.)
+versions of @command{f2c}, or versions having certain configuration changes
+to @command{f2c} internals, will produce object files that are
+incompatible with @command{g77}.)
For example, a Fortran string subroutine
argument will become two arguments on the C side: a @code{char *}
and an @code{int} length.
Much of this compatibility results from the fact that
-@code{g77} uses the same run-time library,
-@code{libf2c}, used by @code{f2c},
-though @code{g77} gives its version the name @code{libg2c}
+@command{g77} uses the same run-time library,
+@code{libf2c}, used by @command{f2c},
+though @command{g77} gives its version the name @code{libg2c}
so as to avoid conflicts when linking,
installing them in the same directories,
and so on.
Other compilers might or might not generate code that
-is object-compatible with @code{libg2c} and current @code{g77},
+is object-compatible with @code{libg2c} and current @command{g77},
and some might offer such compatibility only when explicitly
selected via a command-line option to the compiler.
@end menu
@node Dropping f2c Compatibility
-@section Dropping @code{f2c} Compatibility
+@section Dropping @command{f2c} Compatibility
-Specifying @samp{-fno-f2c} allows @code{g77} to generate, in
+Specifying @option{-fno-f2c} allows @command{g77} to generate, in
some cases, faster code, by not needing to allow to the possibility
-of linking with code compiled by @code{f2c}.
+of linking with code compiled by @command{f2c}.
For example, this affects how @code{REAL(KIND=1)},
@code{COMPLEX(KIND=1)}, and @code{COMPLEX(KIND=2)} functions are called.
-With @samp{-fno-f2c}, they are
-compiled as returning the appropriate @code{gcc} type
+With @option{-fno-f2c}, they are
+compiled as returning the appropriate @command{gcc} type
(@code{float}, @code{__complex__ float}, @code{__complex__ double},
in many configurations).
-With @samp{-ff2c} in force, they
+With @option{-ff2c} in force, they
are compiled differently (with perhaps slower run-time performance)
-to accommodate the restrictions inherent in @code{f2c}'s use of K&R
+to accommodate the restrictions inherent in @command{f2c}'s use of K&R
C as an intermediate language---@code{REAL(KIND=1)} functions
return C's @code{double} type, while @code{COMPLEX} functions return
@code{void} and use an extra argument pointing to a place for the functions to
return their values.
-It is possible that, in some cases, leaving @samp{-ff2c} in force
-might produce faster code than using @samp{-fno-f2c}.
+It is possible that, in some cases, leaving @option{-ff2c} in force
+might produce faster code than using @option{-fno-f2c}.
Feel free to experiment, but remember to experiment with changing the way
@emph{entire programs and their Fortran libraries are compiled} at
a time, since this sort of experimentation affects the interface
of code generated for a Fortran source file---that is, it affects
object compatibility.
-Note that @code{f2c} compatibility is a fairly static target to achieve,
-though not necessarily perfectly so, since, like @code{g77}, it is
+Note that @command{f2c} compatibility is a fairly static target to achieve,
+though not necessarily perfectly so, since, like @command{g77}, it is
still being improved.
-However, specifying @samp{-fno-f2c} causes @code{g77}
+However, specifying @option{-fno-f2c} causes @command{g77}
to generate code that will probably be incompatible with code
-generated by future versions of @code{g77} when the same option
+generated by future versions of @command{g77} when the same option
is in force.
You should make sure you are always able to recompile complete
-programs from source code when upgrading to new versions of @code{g77}
-or @code{f2c}, especially when using options such as @samp{-fno-f2c}.
+programs from source code when upgrading to new versions of @command{g77}
+or @command{f2c}, especially when using options such as @option{-fno-f2c}.
-Therefore, if you are using @code{g77} to compile libraries and other
+Therefore, if you are using @command{g77} to compile libraries and other
object files for possible future use and you don't want to require
-recompilation for future use with subsequent versions of @code{g77},
-you might want to stick with @code{f2c} compatibility for now, and
+recompilation for future use with subsequent versions of @command{g77},
+you might want to stick with @command{f2c} compatibility for now, and
carefully watch for any announcements about changes to the
-@code{f2c}/@code{libf2c} interface that might affect existing programs
+@command{f2c}/@code{libf2c} interface that might affect existing programs
(thus requiring recompilation).
-It is probable that a future version of @code{g77} will not,
-by default, generate object files compatible with @code{f2c},
+It is probable that a future version of @command{g77} will not,
+by default, generate object files compatible with @command{f2c},
and that version probably would no longer use @code{libf2c}.
If you expect to depend on this compatibility in the
long term, use the options @samp{-ff2c -ff2c-library} when compiling
all of the applicable code.
-This should cause future versions of @code{g77} either to produce
+This should cause future versions of @command{g77} either to produce
compatible code (at the expense of the availability of some features and
performance), or at the very least, to produce diagnostics.
-(The library @code{g77} produces will no longer be named @file{libg2c}
+(The library @command{g77} produces will no longer be named @file{libg2c}
when it is no longer generally compatible with @file{libf2c}.
It will likely be referred to, and, if installed as a distinct
library, named @code{libg77}, or some other as-yet-unused name.)
@node Compilers Other Than f2c
-@section Compilers Other Than @code{f2c}
+@section Compilers Other Than @command{f2c}
-On systems with Fortran compilers other than @code{f2c} and @code{g77},
-code compiled by @code{g77} is not expected to work
+On systems with Fortran compilers other than @command{f2c} and @command{g77},
+code compiled by @command{g77} is not expected to work
well with code compiled by the native compiler.
-(This is true for @code{f2c}-compiled objects as well.)
+(This is true for @command{f2c}-compiled objects as well.)
Libraries compiled with the native compiler probably will have
-to be recompiled with @code{g77} to be used with @code{g77}-compiled code.
+to be recompiled with @command{g77} to be used with @command{g77}-compiled code.
Reasons for such incompatibilities include:
There might be differences in the way names of Fortran procedures
are translated for use in the system's object-file format.
For example, the statement @samp{CALL FOO} might be compiled
-by @code{g77} to call a procedure the linker @code{ld} sees
+by @command{g77} to call a procedure the linker @code{ld} sees
given the name @samp{_foo_}, while the apparently corresponding
statement @samp{SUBROUTINE FOO} might be compiled by the
native compiler to define the linker-visible name @samp{_foo},
There might be subtle type mismatches which cause subroutine arguments
and function return values to get corrupted.
-This is why simply getting @code{g77} to
+This is why simply getting @command{g77} to
transform procedure names the same way a native
compiler does is not usually a good idea---unless
some effort has been made to ensure that, aside
@cindex C, linking with
@cindex C++, linking with
@cindex linking with C
-The following discussion assumes that you are running @code{g77} in @code{f2c}
-compatibility mode, i.e.@: not using @samp{-fno-f2c}.
+The following discussion assumes that you are running @command{g77} in @command{f2c}
+compatibility mode, i.e.@: not using @option{-fno-f2c}.
It provides some
advice about quick and simple techniques for linking Fortran and C (or
C++), the most common requirement.
description of code generation.
@xref{Debugging and Interfacing}.
-When linking Fortran and C, it's usually best to use @code{g77} to do
+When linking Fortran and C, it's usually best to use @command{g77} to do
the linking so that the correct libraries are included (including the
maths one).
If you're linking with C++ you will want to add
-@samp{-lstdc++}, @samp{-lg++} or whatever.
+@option{-lstdc++}, @option{-lg++} or whatever.
If you need to use another
driver program (or @code{ld} directly),
you can find out what linkage
-options @code{g77} passes by running @samp{g77 -v}.
+options @command{g77} passes by running @samp{g77 -v}.
@menu
* C Interfacing Tools::
@pindex f2c
@cindex cfortran.h
@cindex Netlib
-Even if you don't actually use it as a compiler, @code{f2c} from
+Even if you don't actually use it as a compiler, @command{f2c} from
@uref{ftp://ftp.netlib.org/f2c/src}, can be a useful tool when you're
interfacing (linking) Fortran and C@.
-@xref{f2c Skeletons and Prototypes,,Generating Skeletons and Prototypes with @code{f2c}}.
+@xref{f2c Skeletons and Prototypes,,Generating Skeletons and Prototypes with @command{f2c}}.
-To use @code{f2c} for this purpose you only need retrieve and
+To use @command{f2c} for this purpose you only need retrieve and
build the @file{src} directory from the distribution, consult the
@file{README} instructions there for machine-specifics, and install the
-@code{f2c} program on your path.
+@command{f2c} program on your path.
Something else that might be useful is @samp{cfortran.h} from
@uref{ftp://zebra.desy.de/cfortran}.
This is a fairly general tool which
can be used to generate interfaces for calling in both directions
between Fortran and C@.
-It can be used in @code{f2c} mode with
-@code{g77}---consult its documentation for details.
+It can be used in @command{f2c} mode with
+@command{g77}---consult its documentation for details.
@node C Access to Type Information
@subsection Accessing Type Information in C
@cindex types, Fortran/C
Generally, C code written to link with
-@code{g77} code---calling and/or being
+@command{g77} code---calling and/or being
called from Fortran---should @samp{#include <g2c.h>} to define the C
versions of the Fortran types.
Don't assume Fortran @code{INTEGER} types
correspond to C @code{int}s, for instance; instead, declare them as
@code{integer}, a type defined by @file{g2c.h}.
-@file{g2c.h} is installed where @code{gcc} will find it by
-default, assuming you use a copy of @code{gcc} compatible with
-@code{g77}, probably built at the same time as @code{g77}.
+@file{g2c.h} is installed where @command{gcc} will find it by
+default, assuming you use a copy of @command{gcc} compatible with
+@command{g77}, probably built at the same time as @command{g77}.
@node f2c Skeletons and Prototypes
-@subsection Generating Skeletons and Prototypes with @code{f2c}
+@subsection Generating Skeletons and Prototypes with @command{f2c}
@pindex f2c
@cindex -fno-second-underscore
-A simple and foolproof way to write @code{g77}-callable C routines---e.g.@: to
+A simple and foolproof way to write @command{g77}-callable C routines---e.g.@: to
interface with an existing library---is to write a file (named, for
example, @file{fred.f}) of dummy Fortran
skeletons comprising just the declaration of the routine(s) and dummy
arguments plus @code{END} statements.
-Then run @code{f2c} on file @file{fred.f} to produce @file{fred.c}
+Then run @command{f2c} on file @file{fred.f} to produce @file{fred.c}
into which you can edit
useful code, confident the calling sequence is correct, at least.
(There are some errors otherwise commonly made in generating C
-interfaces with @code{f2c} conventions,
+interfaces with @command{f2c} conventions,
such as not using @code{doublereal}
as the return type of a @code{REAL} @code{FUNCTION}.)
@pindex ftnchek
-@code{f2c} also can help with calling Fortran from C, using its
-@samp{-P} option to generate C prototypes appropriate for calling the
+@command{f2c} also can help with calling Fortran from C, using its
+@option{-P} option to generate C prototypes appropriate for calling the
Fortran.@footnote{The files generated like this can also be used for
inter-unit consistency checking of dummy and actual arguments, although
the @code{ftnchek} tool from @uref{ftp://ftp.netlib.org/fortran}
the Fortran routines to make sure you get it right.
@xref{Arrays,,Arrays (DIMENSION)}, for information on the differences
-between the way Fortran (including compilers like @code{g77}) and
+between the way Fortran (including compilers like @command{g77}) and
C handle arrays.
@node C++ Considerations
@subsection C++ Considerations
@cindex C++
-@code{f2c} can be used to generate suitable code for compilation with a
-C++ system using the @samp{-C++} option.
-The important thing about linking @code{g77}-compiled
-code with C++ is that the prototypes for the @code{g77}
+@command{f2c} can be used to generate suitable code for compilation with a
+C++ system using the @option{-C++} option.
+The important thing about linking @command{g77}-compiled
+code with C++ is that the prototypes for the @command{g77}
routines must specify C linkage to avoid name mangling.
So, use an @samp{extern "C"} declaration.
-@code{f2c}'s @samp{-C++} option will take care
+@command{f2c}'s @option{-C++} option will take care
of this when generating skeletons or prototype files as above, and also
avoid clashes with C++ reserved words in addition to those in C@.
to use a Fortran main program unit to ensure the
runtime---specifically the I/O system---is initialized.
-However, to use the @code{g77} intrinsics @code{GETARG} and @code{IARGC},
+However, to use the @command{g77} intrinsics @code{GETARG} and @code{IARGC},
either the @code{main} routine from the @file{libg2c} library must be used,
or the @code{f_setarg} routine
-(new as of @code{egcs} version 1.1 and @code{g77} version 0.5.23)
+(new as of @code{egcs} version 1.1 and @command{g77} version 0.5.23)
must be called with the appropriate @code{argc} and @code{argv} arguments
prior to the program calling @code{GETARG} or @code{IARGC}.
To provide more flexibility for mixed-language programming
-involving @code{g77} while allowing for shared libraries,
-as of @code{egcs} version 1.1 and @code{g77} version 0.5.23,
-@code{g77}'s @code{main} routine in @code{libg2c}
+involving @command{g77} while allowing for shared libraries,
+as of @code{egcs} version 1.1 and @command{g77} version 0.5.23,
+@command{g77}'s @code{main} routine in @code{libg2c}
does the following, in order:
@enumerate
are believed to call @code{f_init} automatically,
if necessary.
-(A future version of @code{g77} might skip this explicit step,
+(A future version of @command{g77} might skip this explicit step,
to speed up normal exit of a program.)
@item
This starts executing the Fortran main program unit for
the application.
-(Both @code{g77} and @code{f2c} currently compile a main
+(Both @command{g77} and @command{f2c} currently compile a main
program unit so that its global name is @code{MAIN__}.)
@item
All of the above names are C @code{extern} names,
i.e.@: not mangled.
-When using the @code{main} procedure provided by @code{g77}
+When using the @code{main} procedure provided by @command{g77}
without a Fortran main program unit,
you need to provide @code{MAIN__}
as the entry point for your C code.
entry point with the rest of your program.)
To provide your own @code{main} procedure
-in place of @code{g77}'s,
+in place of @command{g77}'s,
make sure you specify the object file defining that procedure
-@emph{before} @samp{-lg2c} on the @code{g77} command line.
-Since the @samp{-lg2c} option is implicitly provided,
+@emph{before} @option{-lg2c} on the @command{g77} command line.
+Since the @option{-lg2c} option is implicitly provided,
this is usually straightforward.
-(Use the @samp{--verbose} option to see how and where
-@code{g77} implicitly adds @samp{-lg2c} in a command line
+(Use the @option{--verbose} option to see how and where
+@command{g77} implicitly adds @option{-lg2c} in a command line
that will link the program.
-Feel free to specify @samp{-lg2c} explicitly,
+Feel free to specify @option{-lg2c} explicitly,
as appropriate.)
However, when providing your own @code{main},
and some existing files being written might be left
with old data not properly truncated at the end.
-Note that, generally, the @code{g77} operating environment
+Note that, generally, the @command{g77} operating environment
does not depend on a procedure named @code{MAIN__} actually
-being called prior to any other @code{g77}-compiled code.
+being called prior to any other @command{g77}-compiled code.
That is, @code{MAIN__} does not, itself,
set up any important operating-environment characteristics
upon which other code might depend.
-This might change in future versions of @code{g77},
+This might change in future versions of @command{g77},
with appropriate notification in the release notes.
For more information, consult the source code for the above routines.
These are in @file{@value{path-libf2c}/libF77/}, named @file{main.c},
@file{setarg.c}, @file{setsig.c}, @file{getarg_.c}, and @file{iargc_.c}.
-Also, the file @file{@value{path-g77}/com.c} contains the code @code{g77}
+Also, the file @file{@value{path-g77}/com.c} contains the code @command{g77}
uses to open-code (inline) references to @code{IARGC}.
@node Debugging and Interfacing
@cindex f2c compatibility
GNU Fortran currently generates code that is object-compatible with
-the @code{f2c} converter.
+the @command{f2c} converter.
Also, it avoids limitations in the current GBE, such as the
inability to generate a procedure with
multiple entry points, by generating code that is structured
so on) than might be expected.
As a result, writing code in other languages that calls on, is
-called by, or shares in-memory data with @code{g77}-compiled code generally
-requires some understanding of the way @code{g77} compiles code for
+called by, or shares in-memory data with @command{g77}-compiled code generally
+requires some understanding of the way @command{g77} compiles code for
various constructs.
-Similarly, using a debugger to debug @code{g77}-compiled
+Similarly, using a debugger to debug @command{g77}-compiled
code, even if that debugger supports native Fortran debugging, generally
requires this sort of information.
This section describes some of the basic information on how
-@code{g77} compiles code for constructs involving interfaces to other
+@command{g77} compiles code for constructs involving interfaces to other
languages and to debuggers.
@emph{Caution:} Much or all of this information pertains to only the current
-release of @code{g77}, sometimes even to using certain compiler options
-with @code{g77} (such as @samp{-fno-f2c}).
+release of @command{g77}, sometimes even to using certain compiler options
+with @command{g77} (such as @option{-fno-f2c}).
Do not write code that depends on this
information without clearly marking said code as nonportable and
-subject to review for every new release of @code{g77}.
+subject to review for every new release of @command{g77}.
This information
is provided primarily to make debugging of code generated by this
-particular release of @code{g77} easier for the user, and partly to make
+particular release of @command{g77} easier for the user, and partly to make
writing (generally nonportable) interface code easier.
Both of these
-activities require tracking changes in new version of @code{g77} as they
+activities require tracking changes in new version of @command{g77} as they
are installed, because new versions can change the behaviors
described in this section.
@menu
-* Main Program Unit:: How @code{g77} compiles a main program unit.
-* Procedures:: How @code{g77} constructs parameter lists
+* Main Program Unit:: How @command{g77} compiles a main program unit.
+* Procedures:: How @command{g77} constructs parameter lists
for procedures.
* Functions:: Functions returning floating-point or character data.
* Names:: Naming of user-defined variables, procedures, etc.
* Common Blocks:: Accessing common variables while debugging.
* Local Equivalence Areas:: Accessing @code{EQUIVALENCE} while debugging.
-* Complex Variables:: How @code{g77} performs complex arithmetic.
+* Complex Variables:: How @command{g77} performs complex arithmetic.
* Arrays:: Dealing with (possibly multi-dimensional) arrays.
* Adjustable Arrays:: Special consideration for adjustable arrays.
-* Alternate Entry Points:: How @code{g77} implements alternate @code{ENTRY}.
-* Alternate Returns:: How @code{g77} handles alternate returns.
-* Assigned Statement Labels:: How @code{g77} handles @code{ASSIGN}.
+* Alternate Entry Points:: How @command{g77} implements alternate @code{ENTRY}.
+* Alternate Returns:: How @command{g77} handles alternate returns.
+* Assigned Statement Labels:: How @command{g77} handles @code{ASSIGN}.
* Run-time Library Errors:: Meanings of some @code{IOSTAT=} values.
@end menu
@cindex PROGRAM statement
@cindex statements, PROGRAM
-When @code{g77} compiles a main program unit, it gives it the public
+When @command{g77} compiles a main program unit, it gives it the public
procedure name @code{MAIN__}.
The @code{libg2c} library has the actual @code{main()} procedure
as is typical of C-based environments, and
it is this procedure that performs some initial start-up
activity and then calls @code{MAIN__}.
-Generally, @code{g77} and @code{libg2c} are designed so that you need not
+Generally, @command{g77} and @code{libg2c} are designed so that you need not
include a main program unit written in Fortran in your program---it
can be written in C or some other language.
-Especially for I/O handling, this is the case, although @code{g77} version 0.5.16
+Especially for I/O handling, this is the case, although @command{g77} version 0.5.16
includes a bug fix for @code{libg2c} that solved a problem with using the
@code{OPEN} statement as the first Fortran I/O activity in a program
without a Fortran main program unit.
-However, if you don't intend to use @code{g77} (or @code{f2c}) to compile
+However, if you don't intend to use @command{g77} (or @command{f2c}) to compile
your main program unit---that is, if you intend to compile a @code{main()}
procedure using some other language---you should carefully
examine the code for @code{main()} in @code{libg2c}, found in the source
@cindex statements, FUNCTION
@cindex signature of procedures
-Currently, @code{g77} passes arguments via reference---specifically,
+Currently, @command{g77} passes arguments via reference---specifically,
by passing a pointer to the location in memory of a variable, array,
array element, a temporary location that holds the result of evaluating an
expression, or a temporary or permanent location that holds the value
of a constant.
Procedures that accept @code{CHARACTER} arguments are implemented by
-@code{g77} so that each @code{CHARACTER} argument has two actual arguments.
+@command{g77} so that each @code{CHARACTER} argument has two actual arguments.
The first argument occupies the expected position in the
argument list and has the user-specified name.
list, the length arguments are appended in the order
the original arguments appear.
So @samp{CALL FOO('HI','THERE')} is implemented in
-C as @samp{foo("hi","there",2,5);}, ignoring the fact that @code{g77}
+C as @samp{foo("hi","there",2,5);}, ignoring the fact that @command{g77}
does not provide the trailing null bytes on the constant
-strings (@code{f2c} does provide them, but they are unnecessary in
+strings (@command{f2c} does provide them, but they are unnecessary in
a Fortran environment, and you should not expect them to be
there).
@cindex statements, RETURN
@cindex return type of functions
-@code{g77} handles in a special way functions that return the following
+@command{g77} handles in a special way functions that return the following
types:
@itemize @bullet
@code{REAL(KIND=1)}
@end itemize
-For @code{CHARACTER}, @code{g77} implements a subroutine (a C function
+For @code{CHARACTER}, @command{g77} implements a subroutine (a C function
returning @code{void})
with two arguments prepended: @samp{__g77_result}, which the caller passes
as a pointer to a @code{char} array expected to hold the return value,
to determine the size of the array that @samp{__g77_result} points to;
otherwise, it ignores that argument.
-For @code{COMPLEX}, when @samp{-ff2c} is in
-force, @code{g77} implements
+For @code{COMPLEX}, when @option{-ff2c} is in
+force, @command{g77} implements
a subroutine with one argument prepended: @samp{__g77_result}, which the
caller passes as a pointer to a variable of the type of the function.
The called function writes the return value into this variable instead
of returning it as a function value.
-When @samp{-fno-f2c} is in force,
-@code{g77} implements a @code{COMPLEX} function as @code{gcc}'s
+When @option{-fno-f2c} is in force,
+@command{g77} implements a @code{COMPLEX} function as @command{gcc}'s
@samp{__complex__ float} or @samp{__complex__ double} function
-(or an emulation thereof, when @samp{-femulate-complex} is in effect),
-returning the result of the function in the same way as @code{gcc} would.
+(or an emulation thereof, when @option{-femulate-complex} is in effect),
+returning the result of the function in the same way as @command{gcc} would.
-For @code{REAL(KIND=1)}, when @samp{-ff2c} is in force, @code{g77} implements
+For @code{REAL(KIND=1)}, when @option{-ff2c} is in force, @command{g77} implements
a function that actually returns @code{REAL(KIND=2)} (typically
C's @code{double} type).
-When @samp{-fno-f2c} is in force, @code{REAL(KIND=1)}
+When @option{-fno-f2c} is in force, @code{REAL(KIND=1)}
functions return @code{float}.
@node Names
External names---names of entities that are public, or ``accessible'',
to all modules in a program---normally have an underscore (@samp{_})
-appended by @code{g77},
-to generate code that is compatible with @code{f2c}.
+appended by @command{g77},
+to generate code that is compatible with @command{f2c}.
External names include names of Fortran things like common blocks,
external procedures (subroutines and functions, but not including
statement functions, which are internal procedures), and entry point
names.
-However, use of the @samp{-fno-underscoring} option
+However, use of the @option{-fno-underscoring} option
disables this kind of transformation of external names (though inhibiting
the transformation certainly improves the chances of colliding with
incompatible externals written in other languages---but that
@cindex options, -fno-underscoring
@cindex -fno-second-underscore option
@cindex options, -fno-underscoring
-When @samp{-funderscoring} is in force, any name (external or local)
+When @option{-funderscoring} is in force, any name (external or local)
that already has at least one underscore in it is
-implemented by @code{g77} by appending two underscores.
+implemented by @command{g77} by appending two underscores.
(This second underscore can be disabled via the
-@samp{-fno-second-underscore} option.)
-External names are changed this way for @code{f2c} compatibility.
+@option{-fno-second-underscore} option.)
+External names are changed this way for @command{f2c} compatibility.
Local names are changed this way to avoid collisions with external names
-that are different in the source code---@code{f2c} does the same thing, but
+that are different in the source code---@command{f2c} does the same thing, but
there's no compatibility issue there except for user expectations while
debugging.
Here, a user would, in the debugger, refer to this variable using the
name @samp{max_cost__} (or @samp{MAX_COST__} or @samp{Max_Cost__},
as described below).
-(We hope to improve @code{g77} in this regard in the future---don't
+(We hope to improve @command{g77} in this regard in the future---don't
write scripts depending on this behavior!
-Also, consider experimenting with the @samp{-fno-underscoring}
+Also, consider experimenting with the @option{-fno-underscoring}
option to try out debugging without having to massage names by
hand like this.)
-@code{g77} provides a number of command-line options that allow the user
+@command{g77} provides a number of command-line options that allow the user
to control how case mapping is handled for source files.
The default is the traditional UNIX model for Fortran compilers---names
are mapped to lower case.
access the variable.
However, depending on the command-line options specified, the
-name implemented by @code{g77} might instead be @samp{FOO} or even
+name implemented by @command{g77} might instead be @samp{FOO} or even
@samp{Foo}, thus affecting how debugging is done.
Also:
@end example
@noindent
-However, @code{g77} command-line options could be used to change the casing
+However, @command{g77} command-line options could be used to change the casing
of names, resulting in the name @samp{FOO_} or @samp{Foo_} being given to the
-procedure instead of @samp{foo_}, and the @samp{-fno-underscoring} option
+procedure instead of @samp{foo_}, and the @option{-fno-underscoring} option
could be used to inhibit the appending of the underscore to the name.
@node Common Blocks
@cindex @code{COMMON} statement
@cindex statements, @code{COMMON}
-@code{g77} names and lays out @code{COMMON} areas
-the same way @code{f2c} does,
-for compatibility with @code{f2c}.
+@command{g77} names and lays out @code{COMMON} areas
+the same way @command{f2c} does,
+for compatibility with @command{f2c}.
@node Local Equivalence Areas
@section Local Equivalence Areas (EQUIVALENCE)
@cindex EQUIVALENCE statement
@cindex statements, EQUIVALENCE
-@code{g77} treats storage-associated areas involving a @code{COMMON}
+@command{g77} treats storage-associated areas involving a @code{COMMON}
block as explained in the section on common blocks.
A local @code{EQUIVALENCE} area is a collection of variables and arrays
connected to each other in any way via @code{EQUIVALENCE}, none of which are
listed in a @code{COMMON} statement.
-(@emph{Note:} @code{g77} version 0.5.18 and earlier chose the name
+(@emph{Note:} @command{g77} version 0.5.18 and earlier chose the name
for @var{x} using a different method when more than one name was
in the list of names of entities placed at the beginning of the
array.
Though the documentation specified that the first name listed in
-the @code{EQUIVALENCE} statements was chosen for @var{x}, @code{g77}
+the @code{EQUIVALENCE} statements was chosen for @var{x}, @command{g77}
in fact chose the name using a method that was so complicated,
it seemed easier to change it to an alphabetical sort than to describe the
previous method in the documentation.)
@cindex COMPLEX statement
@cindex statements, COMPLEX
-As of 0.5.20, @code{g77} defaults to handling @code{COMPLEX} types
+As of 0.5.20, @command{g77} defaults to handling @code{COMPLEX} types
(and related intrinsics, constants, functions, and so on)
in a manner that
makes direct debugging involving these types in Fortran
language mode difficult.
-Essentially, @code{g77} implements these types using an
+Essentially, @command{g77} implements these types using an
internal construct similar to C's @code{struct}, at least
-as seen by the @code{gcc} back end.
+as seen by the @command{gcc} back end.
Currently, the back end, when outputting debugging info with
the compiled code for the assembler to digest, does not detect
When using a debugger directly on Fortran code, the C equivalent
might not work, because some debuggers cannot understand the notion
-of low bounds other than zero. However, unlike @code{f2c}, @code{g77}
+of low bounds other than zero. However, unlike @command{f2c}, @command{g77}
does inform the GBE that a multi-dimensional array (like @samp{A}
in the above example) is really multi-dimensional, rather than a
single-dimensional array, so at least the dimensionality of the array
Adjustable and automatic arrays in Fortran require the implementation
(in this
-case, the @code{g77} compiler) to ``memorize'' the expressions that
+case, the @command{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
Note that this shows that while the value of @samp{N} was successfully
changed, the size of the @samp{A} array remained at 5 elements.
-To support this, @code{g77} generates code that executes before any user
+To support this, @command{g77} generates code that executes before any user
code (and before the internally generated computed @code{GOTO} to handle
alternate entry points, as described below) that evaluates each
(nonconstant) expression in the list of subscripts for an
of the temporary during execution of the procedure, the size
of the array remains constant during each invocation.
-For alternate entry points, the code @code{g77} generates takes into
+For alternate entry points, the code @command{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 @code{NULL} pointer where a pointer to that
adjustable array would be expected.
-The @code{g77}-generated code
+The @command{g77}-generated code
doesn't attempt to evaluate any of the expressions in the subscripts
for an array if the pointer to that array is @code{NULL} at run time in
such cases.
won't reference the arrays---nor should you pass @code{NULL} pointers
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 @code{g77} implements these things might
+COMMON---because the way @command{g77} implements these things might
change in the future!)
@node Alternate Entry Points
The GBE does not understand the general concept of
alternate entry points as Fortran provides via the ENTRY statement.
-@code{g77} gets around this by using an approach to compiling procedures
+@command{g77} gets around this by using an approach to compiling procedures
having at least one @code{ENTRY} statement that is almost identical to the
-approach used by @code{f2c}.
+approach used by @command{f2c}.
(An alternate approach could be used that
would probably generate faster, but larger, code that would also
be a bit easier to debug.)
-Information on how @code{g77} implements @code{ENTRY} is provided for those
+Information on how @command{g77} implements @code{ENTRY} is provided for those
trying to debug such code.
The choice of implementation seems
unlikely to affect code (compiled in other languages) that interfaces
to such code.
-@code{g77} compiles exactly one public procedure for the primary entry
+@command{g77} compiles exactly one public procedure for the primary entry
point of a procedure plus each @code{ENTRY} point it specifies, as usual.
That is, in terms of the public interface, there is no difference
between
for the second case, an extra internal procedure is compiled.
For every Fortran procedure with at least one @code{ENTRY}
-statement, @code{g77} compiles an extra procedure
+statement, @command{g77} compiles an extra procedure
named @samp{__g77_masterfun_@var{x}}, where @var{x} is
the name of the primary entry point (which, in the above case,
using the standard compiler options, would be @samp{x_} in C).
The extra procedure has some other interesting characteristics.
-The argument list for this procedure is invented by @code{g77}.
+The argument list for this procedure is invented by @command{g77}.
It contains
a single integer argument named @samp{__g77_which_entrypoint},
passed by value (as in Fortran's @samp{%VAL()} intrinsic), specifying the
the second entry point, and so on.
It also contains, for functions returning @code{CHARACTER} and
-(when @samp{-ff2c} is in effect) @code{COMPLEX} functions,
+(when @option{-ff2c} is in effect) @code{COMPLEX} functions,
and for functions returning different types among the
@code{ENTRY} statements (e.g. @samp{REAL FUNCTION R()}
containing @samp{ENTRY I()}), an argument named @samp{__g77_result} that
type; for multiple-return-type functions, it is a union of all the supported return
types (which cannot include @code{CHARACTER}, since combining @code{CHARACTER}
and non-@code{CHARACTER} return types via @code{ENTRY} in a single function
-is not supported by @code{g77}).
+is not supported by @command{g77}).
For @code{CHARACTER} functions, the @samp{__g77_result} argument is followed
by yet another argument named @samp{__g77_length} that, at run time,
@noindent
(Note that invalid Fortran statement labels and variable names
are used in the above example to highlight the fact that it
-represents code generated by the @code{g77} internals, not code to be
+represents code generated by the @command{g77} internals, not code to be
written by the user.)
It is this code that, when the procedure is called, picks which
@cindex statements, RETURN
Subroutines with alternate returns (e.g. @samp{SUBROUTINE X(*)} and
-@samp{CALL X(*50)}) are implemented by @code{g77} as functions returning
+@samp{CALL X(*50)}) are implemented by @command{g77} as functions returning
the C @code{int} type.
The actual alternate-return arguments are omitted from the calling sequence.
Instead, the caller uses
@cindex statements, GOTO
For portability to machines where a pointer (such as to a label,
-which is how @code{g77} implements @code{ASSIGN} and its relatives,
+which is how @command{g77} implements @code{ASSIGN} and its relatives,
the assigned-@code{GOTO} and assigned-@code{FORMAT}-I/O statements)
-is wider (bitwise) than an @code{INTEGER(KIND=1)}, @code{g77}
+is wider (bitwise) than an @code{INTEGER(KIND=1)}, @command{g77}
uses a different memory location to hold the @code{ASSIGN}ed value of a variable
than it does the numerical value in that variable, unless the
variable is wide enough (can hold enough bits).
-In particular, while @code{g77} implements
+In particular, while @command{g77} implements
@example
I = 10
@noindent
as, in GNU's extended C notation (for the label syntax),
@samp{__g77_ASSIGN_I = &&L10;} (where @samp{L10} is just a massaging
-of the Fortran label @samp{10} to make the syntax C-like; @code{g77} doesn't
+of the Fortran label @samp{10} to make the syntax C-like; @command{g77} doesn't
actually generate the name @samp{L10} or any other name like that,
since debuggers cannot access labels anyway).
While this currently means that an @code{ASSIGN} statement does not
overwrite the numeric contents of its target variable, @emph{do not}
write any code depending on this feature.
-@code{g77} has already changed this implementation across
+@command{g77} has already changed this implementation across
versions and might do so in the future.
This information is provided only to make debugging Fortran programs
-compiled with the current version of @code{g77} somewhat easier.
+compiled with the current version of @command{g77} somewhat easier.
If there's no debugger-visible variable named @samp{__g77_ASSIGN_I}
in a program unit that does @samp{ASSIGN 10 TO I}, that probably
-means @code{g77} has decided it can store the pointer to the label directly
+means @command{g77} has decided it can store the pointer to the label directly
into @samp{I} itself.
@xref{Ugly Assigned Labels}, for information on a command-line option
-to force @code{g77} to use the same storage for both normal and
+to force @command{g77} to use the same storage for both normal and
assigned-label uses of a variable.
@node Run-time Library Errors
The information below is culled from the definition
of @code{F_err} in @file{f/runtime/libI77/err.c} in the
-@code{g77} source tree.
+@command{g77} source tree.
@smallexample
100: "error in format"
@cindex writing code
@cindex code, writing
-Most users of @code{g77} can be divided into two camps:
+Most users of @command{g77} can be divided into two camps:
@itemize @bullet
@item
-Those writing new Fortran code to be compiled by @code{g77}.
+Those writing new Fortran code to be compiled by @command{g77}.
@item
-Those using @code{g77} to compile existing, ``legacy'' code.
+Those using @command{g77} to compile existing, ``legacy'' code.
@end itemize
Users writing new code generally understand most of the necessary
experience with Fortran, but believe that the code they're compiling
already works when compiled by other compilers (and might
not understand why, as is sometimes the case, it doesn't work
-when compiled by @code{g77}).
+when compiled by @command{g77}).
The following information is designed to help users do a better job
coping with existing, ``legacy'' Fortran code, and with writing
new code as well.
@menu
-* Advantages Over f2c:: If @code{f2c} is so great, why @code{g77}?
-* Block Data and Libraries:: How @code{g77} solves a common problem.
+* Advantages Over f2c:: If @command{f2c} is so great, why @command{g77}?
+* Block Data and Libraries:: How @command{g77} solves a common problem.
* Loops:: Fortran @code{DO} loops surprise many people.
* Working Programs:: Getting programs to work should be done first.
* Overly Convenient Options:: Temptations to avoid, habits to not form.
@node Advantages Over f2c
@section Advantages Over f2c
-Without @code{f2c}, @code{g77} would have taken much longer to
+Without @command{f2c}, @command{g77} would have taken much longer to
do and probably not been as good for quite a while.
-Sometimes people who notice how much @code{g77} depends on, and
-documents encouragement to use, @code{f2c} ask why @code{g77}
-was created if @code{f2c} already existed.
+Sometimes people who notice how much @command{g77} depends on, and
+documents encouragement to use, @command{f2c} ask why @command{g77}
+was created if @command{f2c} already existed.
This section gives some basic answers to these questions, though it
is not intended to be comprehensive.
@node Language Extensions
@subsection Language Extensions
-@code{g77} offers several extensions to FORTRAN 77 language that @code{f2c}
+@command{g77} offers several extensions to FORTRAN 77 language that @command{f2c}
doesn't:
@itemize @bullet
to change the interfaces used by Fortran routines)
@end itemize
-@code{g77} also implements iterative @code{DO} loops
+@command{g77} also implements iterative @code{DO} loops
so that they work even in the presence of certain ``extreme'' inputs,
-unlike @code{f2c}.
+unlike @command{f2c}.
@xref{Loops}.
-However, @code{f2c} offers a few that @code{g77} doesn't, such as:
+However, @command{f2c} offers a few that @command{g77} doesn't, such as:
@itemize @bullet
@item
@code{AUTOMATIC} statement
@end itemize
-It is expected that @code{g77} will offer some or all of these missing
+It is expected that @command{g77} will offer some or all of these missing
features at some time in the future.
@node Diagnostic Abilities
@subsection Diagnostic Abilities
-@code{g77} offers better diagnosis of problems in @code{FORMAT} statements.
-@code{f2c} doesn't, for example, emit any diagnostic for
+@command{g77} offers better diagnosis of problems in @code{FORMAT} statements.
+@command{f2c} doesn't, for example, emit any diagnostic for
@samp{FORMAT(XZFAJG10324)},
leaving that to be diagnosed, at run time, by
the @code{libf2c} run-time library.
@node Compiler Options
@subsection Compiler Options
-@code{g77} offers compiler options that @code{f2c} doesn't,
+@command{g77} offers compiler options that @command{f2c} doesn't,
most of which are designed to more easily accommodate
legacy code:
Fortran-90-style free-form
@end itemize
-However, @code{f2c} offers a few that @code{g77} doesn't,
+However, @command{f2c} offers a few that @command{g77} doesn't,
like an option to have @code{REAL} default to @code{REAL*8}.
-It is expected that @code{g77} will offer all of the
+It is expected that @command{g77} will offer all of the
missing options pertinent to being a Fortran compiler
at some time in the future.
@subsection Compiler Speed
Saving the steps of writing and then rereading C code is a big reason
-why @code{g77} should be able to compile code much faster than using
-@code{f2c} in conjunction with the equivalent invocation of @code{gcc}.
+why @command{g77} should be able to compile code much faster than using
+@command{f2c} in conjunction with the equivalent invocation of @command{gcc}.
-However, due to @code{g77}'s youth, lots of self-checking is still being
+However, due to @command{g77}'s youth, lots of self-checking is still being
performed.
As a result, this improvement is as yet unrealized
(though the potential seems to be there for quite a big speedup
in the future).
-It is possible that, as of version 0.5.18, @code{g77}
+It is possible that, as of version 0.5.18, @command{g77}
is noticeably faster compiling many Fortran source files than using
-@code{f2c} in conjunction with @code{gcc}.
+@command{f2c} in conjunction with @command{gcc}.
@node Program Speed
@subsection Program Speed
-@code{g77} has the potential to better optimize code than @code{f2c},
-even when @code{gcc} is used to compile the output of @code{f2c},
-because @code{f2c} must necessarily
+@command{g77} has the potential to better optimize code than @command{f2c},
+even when @command{gcc} is used to compile the output of @command{f2c},
+because @command{f2c} must necessarily
translate Fortran into a somewhat lower-level language (C) that cannot
preserve all the information that is potentially useful for optimization,
-while @code{g77} can gather, preserve, and transmit that information directly
+while @command{g77} can gather, preserve, and transmit that information directly
to the GBE.
-For example, @code{g77} implements @code{ASSIGN} and assigned
+For example, @command{g77} implements @code{ASSIGN} and assigned
@code{GOTO} using direct assignment of pointers to labels and direct
-jumps to labels, whereas @code{f2c} maps the assigned labels to
+jumps to labels, whereas @command{f2c} maps the assigned labels to
integer values and then uses a C @code{switch} statement to encode
the assigned @code{GOTO} statements.
However, as is typical, theory and reality don't quite match, at least
-not in all cases, so it is still the case that @code{f2c} plus @code{gcc}
-can generate code that is faster than @code{g77}.
+not in all cases, so it is still the case that @command{f2c} plus @command{gcc}
+can generate code that is faster than @command{g77}.
-Version 0.5.18 of @code{g77} offered default
-settings and options, via patches to the @code{gcc}
+Version 0.5.18 of @command{g77} offered default
+settings and options, via patches to the @command{gcc}
back end, that allow for better program speed, though
some of these improvements also affected the performance
-of programs translated by @code{f2c} and then compiled
-by @code{g77}'s version of @code{gcc}.
+of programs translated by @command{f2c} and then compiled
+by @command{g77}'s version of @command{gcc}.
-Version 0.5.20 of @code{g77} offers further performance
+Version 0.5.20 of @command{g77} offers further performance
improvements, at least one of which (alias analysis) is
-not generally applicable to @code{f2c} (though @code{f2c}
+not generally applicable to @command{f2c} (though @command{f2c}
could presumably be changed to also take advantage of
-this new capability of the @code{gcc} back end, assuming
-this is made available in an upcoming release of @code{gcc}).
+this new capability of the @command{gcc} back end, assuming
+this is made available in an upcoming release of @command{gcc}).
@node Ease of Debugging
@subsection Ease of Debugging
-Because @code{g77} compiles directly to assembler code like @code{gcc},
-instead of translating to an intermediate language (C) as does @code{f2c},
-support for debugging can be better for @code{g77} than @code{f2c}.
+Because @command{g77} compiles directly to assembler code like @command{gcc},
+instead of translating to an intermediate language (C) as does @command{f2c},
+support for debugging can be better for @command{g77} than @command{f2c}.
-However, although @code{g77} might be somewhat more ``native'' in terms of
-debugging support than @code{f2c} plus @code{gcc}, there still are a lot
+However, although @command{g77} might be somewhat more ``native'' in terms of
+debugging support than @command{f2c} plus @command{gcc}, there still are a lot
of things ``not quite right''.
Many of the important ones should be resolved in the near future.
-For example, @code{g77} doesn't have to worry about reserved names
-like @code{f2c} does.
-Given @samp{FOR = WHILE}, @code{f2c} must necessarily
+For example, @command{g77} doesn't have to worry about reserved names
+like @command{f2c} does.
+Given @samp{FOR = WHILE}, @command{f2c} must necessarily
translate this to something @emph{other} than
@samp{for = while;}, because C reserves those words.
-However, @code{g77} does still uses things like an extra level of indirection
+However, @command{g77} does still uses things like an extra level of indirection
for @code{ENTRY}-laden procedures---in this case, because the back end doesn't
yet support multiple entry points.
@end smallexample
@noindent
-the @code{g77} user should be able to access the variables directly, by name,
-without having to traverse C-like structures and unions, while @code{f2c}
+the @command{g77} user should be able to access the variables directly, by name,
+without having to traverse C-like structures and unions, while @command{f2c}
is unlikely to ever offer this ability (due to limitations in the
C language).
-However, due to apparent bugs in the back end, @code{g77} currently doesn't
+However, due to apparent bugs in the back end, @command{g77} currently doesn't
take advantage of this facility at all---it doesn't emit any debugging
information for @code{COMMON} and @code{EQUIVALENCE} areas,
other than information
of local @code{EQUIVALENCE}, names) for each such area.
Yet another example is arrays.
-@code{g77} represents them to the debugger
-using the same ``dimensionality'' as in the source code, while @code{f2c}
+@command{g77} represents them to the debugger
+using the same ``dimensionality'' as in the source code, while @command{f2c}
must necessarily convert them all to one-dimensional arrays to fit
into the confines of the C language.
However, the level of support
offered by debuggers for interactive Fortran-style access to arrays
-as compiled by @code{g77} can vary widely.
+as compiled by @command{g77} can vary widely.
In some cases, it can actually
-be an advantage that @code{f2c} converts everything to widely supported
+be an advantage that @command{f2c} converts everything to widely supported
C semantics.
-In fairness, @code{g77} could do many of the things @code{f2c} does
-to get things working at least as well as @code{f2c}---for now,
-the developers prefer making @code{g77} work the
+In fairness, @command{g77} could do many of the things @command{f2c} does
+to get things working at least as well as @command{f2c}---for now,
+the developers prefer making @command{g77} work the
way they think it is supposed to, and finding help improving the
-other products (the back end of @code{gcc}; @code{gdb}; and so on)
+other products (the back end of @command{gcc}; @code{gdb}; and so on)
to get things working properly.
@node Character and Hollerith Constants
@cindex zero byte, trailing
To avoid the extensive hassle that would be needed to avoid this,
-@code{f2c} uses C character constants to encode character and Hollerith
+@command{f2c} uses C character constants to encode character and Hollerith
constants.
That means a constant like @samp{'HELLO'} is translated to
@samp{"hello"} in C, which further means that an extra null byte is
present at the end of the constant.
This null byte is superfluous.
-@code{g77} does not generate such null bytes.
+@command{g77} does not generate such null bytes.
This represents significant
savings of resources, such as on systems where @file{/dev/null} or
@file{/dev/zero} represent bottlenecks in the systems' performance,
-because @code{g77} simply asks for fewer zeros from the operating
-system than @code{f2c}.
+because @command{g77} simply asks for fewer zeros from the operating
+system than @command{f2c}.
(Avoiding spurious use of zero bytes, each byte typically have
eight zero bits, also reduces the liabilities in case
Microsoft's rumored patent on the digits 0 and 1 is upheld.)
@samp{BLOCK DATA FOO}) and make sure there is an @samp{EXTERNAL FOO}
statement in every program unit that uses any common block
initialized by the corresponding @code{BLOCK DATA}.
-@code{g77} currently compiles a @code{BLOCK DATA} as if it were a
+@command{g77} currently compiles a @code{BLOCK DATA} as if it were a
@code{SUBROUTINE},
that is, it generates an actual procedure having the appropriate name.
The procedure does nothing but return immediately if it happens to be
called.
For @samp{EXTERNAL FOO}, where @samp{FOO} is not otherwise referenced in the
-same program unit, @code{g77} assumes there exists a @samp{BLOCK DATA FOO}
+same program unit, @command{g77} assumes there exists a @samp{BLOCK DATA FOO}
in the program and ensures that by generating a
reference to it so the linker will make sure it is present.
-(Specifically, @code{g77} outputs in the data section a static pointer to the
+(Specifically, @command{g77} outputs in the data section a static pointer to the
external name @samp{FOO}.)
-The implementation @code{g77} currently uses to make this work is
-one of the few things not compatible with @code{f2c} as currently
+The implementation @command{g77} currently uses to make this work is
+one of the few things not compatible with @command{f2c} as currently
shipped.
-@code{f2c} currently does nothing with @samp{EXTERNAL FOO} except
+@command{f2c} currently does nothing with @samp{EXTERNAL FOO} except
issue a warning that @samp{FOO} is not otherwise referenced,
and, for @samp{BLOCK DATA FOO},
-@code{f2c} doesn't generate a dummy procedure with the name @samp{FOO}.
-The upshot is that you shouldn't mix @code{f2c} and @code{g77} in
+@command{f2c} doesn't generate a dummy procedure with the name @samp{FOO}.
+The upshot is that you shouldn't mix @command{f2c} and @command{g77} in
this particular case.
-If you use @code{f2c} to compile @samp{BLOCK DATA FOO},
-then any @code{g77}-compiled program unit that says @samp{EXTERNAL FOO}
+If you use @command{f2c} to compile @samp{BLOCK DATA FOO},
+then any @command{g77}-compiled program unit that says @samp{EXTERNAL FOO}
will result in an unresolved reference when linked.
If you do the
opposite, then @samp{FOO} might not be linked in under various
with little or no warning by omitting initializations of global data
because they are contained in unreferenced procedures).
-The changes you make to your code to make @code{g77} handle this situation,
+The changes you make to your code to make @command{g77} handle this situation,
however, appear to be a widely portable way to handle it.
That is, many systems permit it (as they should, since the
FORTRAN 77 standard permits @samp{EXTERNAL FOO} when @samp{FOO}
@end smallexample
@noindent
-That way, @samp{CURX} is compiled by @code{g77} (and many other
+That way, @samp{CURX} is compiled by @command{g77} (and many other
compilers) so that the linker knows it must include @samp{FOO},
the @code{BLOCK DATA} program unit that sets the initial values
for the variables in @samp{VAR}, in the executable program.
@noindent
The simple @code{DO} construct and the @code{EXIT} statement
(used to leave the innermost loop)
-are F90 features that @code{g77} supports.
+are F90 features that @command{g77} supports.
Some Fortran compilers have buggy implementations of @code{DO},
in that they don't follow the standard.
@noindent
A loop started by the above statement will work as implemented
-by @code{g77}, but the use, by some compilers, of a
+by @command{g77}, but the use, by some compilers, of a
more C-like implementation akin to
@smallexample
A C-like view of @code{DO} would hold that the two ``exclamatory''
@code{PRINT} statements are never executed.
However, this is the output of running the above program
-as compiled by @code{g77} on a GNU/Linux ix86 system:
+as compiled by @command{g77} on a GNU/Linux ix86 system:
@smallexample
.100000001
Note that one of the two checks in the program turned up
an apparent violation of the programmer's expectation---yet,
-the loop is correctly implemented by @code{g77}, in that
+the loop is correctly implemented by @command{g77}, in that
it has 30 iterations.
This trip count of 30 is correct when evaluated using
the floating-point representations for the @var{begin},
@var{end}, and @var{incr} values (.1, .31, .007) on GNU/Linux
ix86 are used.
On other systems, an apparently more accurate trip count
-of 31 might result, but, nevertheless, @code{g77} is
+of 31 might result, but, nevertheless, @command{g77} is
faithfully following the Fortran standard, and the result
is not what the author of the sample program above
apparently expected.
Due to this combination of imprecise representation
of floating-point values and the often-misunderstood
interpretation of @code{DO} by standard-conforming
-compilers such as @code{g77}, use of @code{DO} loops
+compilers such as @command{g77}, use of @code{DO} loops
with @code{REAL} iteration
variables is not recommended.
-Such use can be caught by specifying @samp{-Wsurprising}.
+Such use can be caught by specifying @option{-Wsurprising}.
@xref{Warning Options}, for more information on this
option.
quite a challenge---even when the programs already work on
other systems, or when using other compilers.
-@code{g77} offers some facilities that might be useful for
+@command{g77} offers some facilities that might be useful for
tracking down bugs in such programs.
@menu
@code{INTEGER}, or some other type, leading to invalid results
or even program crashes.
-The @samp{-Wimplicit} option might catch failures to
+The @option{-Wimplicit} option might catch failures to
properly specify the types of
variables, arrays, and functions in the code.
recommend widespread use of the @code{IMPLICIT NONE} statement,
despite it not being standard FORTRAN 77, to completely turn
off implicit typing.
-(@code{g77} supports @code{IMPLICIT NONE}, as do almost all
+(@command{g77} supports @code{IMPLICIT NONE}, as do almost all
FORTRAN 77 compilers.)
-Note that @samp{-Wimplicit} catches only implicit typing of
+Note that @option{-Wimplicit} catches only implicit typing of
@emph{names}.
It does not catch implicit typing of expressions such
as @samp{X**(2/3)}.
inadvertently, on this behavior, though to do so violates
the Fortran standards.
-You can ask @code{g77} for this behavior by specifying the
-@samp{-finit-local-zero} option when compiling Fortran code.
-(You might want to specify @samp{-fno-automatic} as well,
+You can ask @command{g77} for this behavior by specifying the
+@option{-finit-local-zero} option when compiling Fortran code.
+(You might want to specify @option{-fno-automatic} as well,
to avoid code-size inflation for non-optimized compilations.)
Note that a program that works better when compiled with the
-@samp{-finit-local-zero} option
+@option{-finit-local-zero} option
is almost certainly depending on a particular system's,
or compiler's, tendency to initialize some variables to zero.
It might be worthwhile finding such cases and fixing them,
-using techniques such as compiling with the @samp{-O -Wuninitialized}
-options using @code{g77}.
+using techniques such as compiling with the @option{-O -Wuninitialized}
+options using @command{g77}.
@node Variables Assumed To Be Saved
@subsection Variables Assumed To Be Saved
procedure calls without using @code{SAVE} to require it violates
the Fortran standards.
-You can ask @code{g77} to assume @code{SAVE} is specified for all
+You can ask @command{g77} to assume @code{SAVE} is specified for all
relevant (local) variables and arrays by using the
-@samp{-fno-automatic} option.
+@option{-fno-automatic} option.
Note that a program that works better when compiled with the
-@samp{-fno-automatic} option
+@option{-fno-automatic} option
is almost certainly depending on not having to use
the @code{SAVE} statement as required by the Fortran standard.
It might be worthwhile finding such cases and fixing them,
using techniques such as compiling with the @samp{-O -Wuninitialized}
-options using @code{g77}.
+options using @command{g77}.
@node Unwanted Variables
@subsection Unwanted Variables
-The @samp{-Wunused} option can find bugs involving
+The @option{-Wunused} option can find bugs involving
implicit typing, sometimes
-more easily than using @samp{-Wimplicit} in code that makes
+more easily than using @option{-Wimplicit} in code that makes
heavy use of implicit typing.
An unused variable or array might indicate that the
spelling for its declaration is different from that of
Compile with @samp{-W -Wunused} option to catch cases of
unused arguments.
-Note that @samp{-W} also enables warnings regarding overflow
+Note that @option{-W} also enables warnings regarding overflow
of floating-point constants under certain circumstances.
@node Surprising Interpretations of Code
@subsection Surprising Interpretations of Code
-The @samp{-Wsurprising} option can help find bugs involving
+The @option{-Wsurprising} option can help find bugs involving
expression evaluation or in
the way @code{DO} loops with non-integral iteration variables
are handled.
Cases found by this option might indicate a difference of
interpretation between the author of the code involved, and
-a standard-conforming compiler such as @code{g77}.
+a standard-conforming compiler such as @command{g77}.
Such a difference might produce actual bugs.
In any case, changing the code to explicitly do what the
-programmer might have expected it to do, so @code{g77} and
+programmer might have expected it to do, so @command{g77} and
other compilers are more likely to follow the programmer's
expectations, might be worthwhile, especially if such changes
make the program work better.
@cindex scheduling of reads and writes
@cindex reads and writes, scheduling
-The @samp{-falias-check}, @samp{-fargument-alias},
-@samp{-fargument-noalias},
-and @samp{-fno-argument-noalias-global} options,
+The @option{-falias-check}, @option{-fargument-alias},
+@option{-fargument-noalias},
+and @option{-fno-argument-noalias-global} options,
introduced in version 0.5.20 and
-@code{g77}'s version 2.7.2.2.f.2 of @code{gcc},
-were withdrawn as of @code{g77} version 0.5.23
-due to their not being supported by @code{gcc} version 2.8.
+@command{g77}'s version 2.7.2.2.f.2 of @command{gcc},
+were withdrawn as of @command{g77} version 0.5.23
+due to their not being supported by @command{gcc} version 2.8.
These options control the assumptions regarding aliasing
(overlapping) of writes and reads to main memory (core) made
-by the @code{gcc} back end.
+by the @command{gcc} back end.
The information below still is useful, but applies to
-only those versions of @code{g77} that support the
+only those versions of @command{g77} that support the
alias analysis implied by support for these options.
-These options are effective only when compiling with @samp{-O}
-(specifying any level other than @samp{-O0})
-or with @samp{-falias-check}.
+These options are effective only when compiling with @option{-O}
+(specifying any level other than @option{-O0})
+or with @option{-falias-check}.
-The default for Fortran code is @samp{-fargument-noalias-global}.
+The default for Fortran code is @option{-fargument-noalias-global}.
(The default for C code and code written in other C-based languages
-is @samp{-fargument-alias}.
-These defaults apply regardless of whether you use @code{g77} or
-@code{gcc} to compile your code.)
+is @option{-fargument-alias}.
+These defaults apply regardless of whether you use @command{g77} or
+@command{gcc} to compile your code.)
-Note that, on some systems, compiling with @samp{-fforce-addr} in
+Note that, on some systems, compiling with @option{-fforce-addr} in
effect can produce more optimal code when the default aliasing
options are in effect (and when optimization is enabled).
(The FORTRAN 77 standard's prohibition of this sort of
overlap, generally referred to therein as ``storage
assocation'', appears in Sections 15.9.3.6.
-This prohibition allows implementations, such as @code{g77},
+This prohibition allows implementations, such as @command{g77},
to, for example, implement the passing of procedures and
even values in @code{COMMON} via copy operations into local,
perhaps more efficiently accessed temporaries at entry to a
among other things.)
To test this hypothesis, try compiling your program with
-the @samp{-fargument-alias} option, which causes the
+the @option{-fargument-alias} option, which causes the
compiler to revert to assumptions essentially the same as
-made by versions of @code{g77} prior to 0.5.20.
+made by versions of @command{g77} prior to 0.5.20.
If the program works using this option, that strongly suggests
that the bug is in your program.
Finding and fixing the bug(s) should result in a program that
-is more standard-conforming and that can be compiled by @code{g77}
+is more standard-conforming and that can be compiled by @command{g77}
in a way that results in a faster executable.
-(You might want to try compiling with @samp{-fargument-noalias},
+(You might want to try compiling with @option{-fargument-noalias},
a kind of half-way point, to see if the problem is limited to
aliasing between dummy arguments and @code{COMMON} variables---this
option assumes that such aliasing is not done, while still allowing
Neither approach can cope with programs mixing Fortran code with
routines written in other languages, however.)
-Currently, @code{g77} provides neither static nor run-time facilities
+Currently, @command{g77} provides neither static nor run-time facilities
to detect any cases of this problem, although other products might.
Run-time facilities are more likely to be offered by future
-versions of @code{g77}, though patches improving @code{g77} so that
+versions of @command{g77}, though patches improving @command{g77} so that
it provides either form of detection are welcome.
@node Output Assumed To Flush
@cindex NFS
@cindex network file system
-For several versions prior to 0.5.20, @code{g77} configured its
+For several versions prior to 0.5.20, @command{g77} configured its
version of the @code{libf2c} run-time library so that one of
its configuration macros, @code{ALWAYS_FLUSH}, was defined.
relevant @code{ERR=} and @code{IOSTAT=} mechanism.
Because of the adverse effects this approach had on the performance
-of many programs, @code{g77} no longer configures @code{libf2c}
-(now named @code{libg2c} in its @code{g77} incarnation)
+of many programs, @command{g77} no longer configures @code{libf2c}
+(now named @code{libg2c} in its @command{g77} incarnation)
to always flush output.
If your program depends on this behavior, either insert the
appropriate @samp{CALL FLUSH} statements, or modify the sources
-to the @code{libg2c}, rebuild and reinstall @code{g77}, and
+to the @code{libg2c}, rebuild and reinstall @command{g77}, and
relink your programs with the modified library.
(Ideally, @code{libg2c} would offer the choice at run-time, so
-that a compile-time option to @code{g77} or @code{f2c} could
+that a compile-time option to @command{g77} or @command{f2c} could
result in generating the appropriate calls to flushing or
non-flushing library routines.)
If you know that Fortran programs requiring this level of precision
of error reporting are to be compiled using the
-version of @code{g77} you are building, you might wish to
-modify the @code{g77} source tree so that the version of
+version of @command{g77} you are building, you might wish to
+modify the @command{g77} source tree so that the version of
@code{libg2c} is built with the @code{ALWAYS_FLUSH} macro
defined, enabling this behavior.
To do this, find this line in @file{@value{path-libf2c}/f2c.h} in
-your @code{g77} source tree:
+your @command{g77} source tree:
@example
/* #define ALWAYS_FLUSH */
so the line begins with @samp{#define},
and the trailing @samp{@w{ }*/}.
-Then build or rebuild @code{g77} as appropriate.
+Then build or rebuild @command{g77} as appropriate.
@node Large File Unit Numbers
@subsection Large File Unit Numbers
If you can easily change your program to use unit numbers
in the range 0 through 99, you should do so.
-As distributed, whether as part of @code{f2c} or @code{g77},
+As distributed, whether as part of @command{f2c} or @command{g77},
@code{libf2c} accepts file unit numbers only in the range
0 through 99.
For example, a statement such as @samp{WRITE (UNIT=100)} causes
number, to an appropriately higher value.
To do this, edit the file @file{@value{path-libf2c}/libI77/fio.h} in your
-@code{g77} source tree, changing the following line:
+@command{g77} source tree, changing the following line:
@example
#define MXUNIT 100
(For example, a program that does @samp{WRITE (UNIT=255)} would require
@code{MXUNIT} set to at least 256 to avoid crashing.)
-Then build or rebuild @code{g77} as appropriate.
+Then build or rebuild @command{g77} as appropriate.
@emph{Note:} Changing this macro has @emph{no} effect on other limits
your system might place on the number of files open at the same time.
@cindex x86 floating-point
If your program depends on exact IEEE 754 floating-point handling it may
help on some systems---specifically x86 or m68k hardware---to use
-the @samp{-ffloat-store} option or to reset the precision flag on the
+the @option{-ffloat-store} option or to reset the precision flag on the
floating-point unit.
@xref{Optimize Options}.
However, it might be better simply to put the FPU into double precision
-mode and not take the performance hit of @samp{-ffloat-store}. On x86
+mode and not take the performance hit of @option{-ffloat-store}. On x86
and m68k GNU systems you can do this with a technique similar to that
for turning on floating-point exceptions
(@pxref{Floating-point Exception Handling}).
(Use, say, @code{ftnchek} to ensure
consistency across source files.
@xref{f2c Skeletons and Prototypes,,
-Generating Skeletons and Prototypes with @code{f2c}}.)
+Generating Skeletons and Prototypes with @command{f2c}}.)
Mysterious errors, which may appear to be code generation problems, can
appear specifically on the x86 architecture with some such
It is safer (and probably
would produce a faster program) to find the variables and arrays that
need such initialization and provide it explicitly via @code{DATA}, so that
-@samp{-finit-local-zero} is not needed.
+@option{-finit-local-zero} is not needed.
-Consider using @samp{-Wuninitialized} (which requires @samp{-O}) to
+Consider using @option{-Wuninitialized} (which requires @option{-O}) to
find likely candidates, but
-do not specify @samp{-finit-local-zero} or @samp{-fno-automatic},
+do not specify @option{-finit-local-zero} or @option{-fno-automatic},
or this technique won't work.
@cindex -fno-automatic option
If so, rather than relying on this command-line option (and hoping all
compilers provide the equivalent one), add @code{SAVE}
statements to some or all program unit sources, as appropriate.
-Consider using @samp{-Wuninitialized} (which requires @samp{-O})
+Consider using @option{-Wuninitialized} (which requires @option{-O})
to find likely candidates, but
-do not specify @samp{-finit-local-zero} or @samp{-fno-automatic},
+do not specify @option{-finit-local-zero} or @option{-fno-automatic},
or this technique won't work.
-The default is @samp{-fautomatic}, which tells @code{g77} to try
+The default is @option{-fautomatic}, which tells @command{g77} to try
and put variables and arrays on the stack (or in fast registers)
where possible and reasonable.
This tends to make programs faster.
@code{SAVE} attribute in procedures declared @code{RECURSIVE},
and local arrays declared with non-constant bounds (automatic
arrays).
-Currently, @code{g77} supports only automatic arrays, not
+Currently, @command{g77} supports only automatic arrays, not
@code{RECURSIVE} procedures or other means of explicitly
specifying that variables or arrays are automatic.
@item -f@var{group}-intrinsics-hide
Change the source code to use @code{EXTERNAL} for any external procedure
that might be the name of an intrinsic.
-It is easy to find these using @samp{-f@var{group}-intrinsics-disable}.
+It is easy to find these using @option{-f@var{group}-intrinsics-disable}.
@end table
@node Faster Programs
@cindex speed, of programs
@cindex programs, speeding up
-Aside from the usual @code{gcc} options, such as @samp{-O},
-@samp{-ffast-math}, and so on, consider trying some of the
+Aside from the usual @command{gcc} options, such as @option{-O},
+@option{-ffast-math}, and so on, consider trying some of the
following approaches to speed up your program (once you get
it working).
@item
@cindex -malign-double option
@cindex options, -malign-double
-Use the (x86-specific) @samp{-malign-double} option when compiling
+Use the (x86-specific) @option{-malign-double} option when compiling
programs for the Pentium and Pentium Pro architectures (called 586
-and 686 in the @code{gcc} configuration subsystem).
-The warning about this in the @code{gcc} manual isn't
+and 686 in the @command{gcc} configuration subsystem).
+The warning about this in the @command{gcc} manual isn't
generally relevant to Fortran,
but using it will force @code{COMMON} to be padded if necessary to align
@code{DOUBLE PRECISION} data.
When @code{DOUBLE PRECISION} data is forcibly aligned
-in @code{COMMON} by @code{g77} due to specifying @samp{-malign-double},
-@code{g77} issues a warning about the need to
+in @code{COMMON} by @command{g77} due to specifying @option{-malign-double},
+@command{g77} issues a warning about the need to
insert padding.
In this case, each and every program unit that uses
the same @code{COMMON} area
must specify the same layout of variables and their types
for that area
-and be compiled with @samp{-malign-double} as well.
-@code{g77} will issue warnings in each case,
+and be compiled with @option{-malign-double} as well.
+@command{g77} will issue warnings in each case,
but as long as every program unit using that area
is compiled with the same warnings,
the resulting object files should work when linked together
@end itemize
Progress is being made on making this work
-``out of the box'' on future versions of @code{g77},
-@code{gcc}, and some of the relevant operating systems
+``out of the box'' on future versions of @command{g77},
+@command{gcc}, and some of the relevant operating systems
(such as GNU/Linux).
@cindex alignment testing
@cindex testing alignment
A package that tests the degree to which a Fortran compiler
-(such as @code{g77})
+(such as @command{g77})
aligns 64-bit floating-point variables and arrays
is available at @uref{ftp://alpha.gnu.org/gnu/g77/align/}.
@node Prefer Automatic Uninitialized Variables
@subsection Prefer Automatic Uninitialized Variables
-If you're using @samp{-fno-automatic} already, you probably
-should change your code to allow compilation with @samp{-fautomatic}
+If you're using @option{-fno-automatic} already, you probably
+should change your code to allow compilation with @option{-fautomatic}
(the default), to allow the program to run faster.
-Similarly, you should be able to use @samp{-fno-init-local-zero}
-(the default) instead of @samp{-finit-local-zero}.
+Similarly, you should be able to use @option{-fno-init-local-zero}
+(the default) instead of @option{-finit-local-zero}.
This is because it is rare that every variable affected by these
options in a given program actually needs to
be so affected.
-For example, @samp{-fno-automatic}, which effectively @code{SAVE}s
+For example, @option{-fno-automatic}, which effectively @code{SAVE}s
every local non-automatic variable and array, affects even things like
@code{DO} iteration
variables, which rarely need to be @code{SAVE}d, and this often reduces
run-time performances.
-Similarly, @samp{-fno-init-local-zero} forces such
+Similarly, @option{-fno-init-local-zero} forces such
variables to be initialized to zero---when @code{SAVE}d (such as when
-@samp{-fno-automatic}), this by itself generally affects only
+@option{-fno-automatic}), this by itself generally affects only
startup time for a program, but when not @code{SAVE}d,
it can slow down the procedure every time it is called.
@xref{Overly Convenient Options,,Overly Convenient Command-Line Options},
-for information on the @samp{-fno-automatic} and
-@samp{-finit-local-zero} options and how to convert
+for information on the @option{-fno-automatic} and
+@option{-finit-local-zero} options and how to convert
their use into selective changes in your own code.
@node Avoid f2c Compatibility
@subsection Avoid f2c Compatibility
@cindex -fno-f2c option
@cindex options, -fno-f2c
-@cindex @code{f2c} compatibility
-@cindex compatibility, @code{f2c}
+@cindex @command{f2c} compatibility
+@cindex compatibility, @command{f2c}
If you aren't linking with any code compiled using
-@code{f2c}, try using the @samp{-fno-f2c} option when
+@command{f2c}, try using the @option{-fno-f2c} option when
compiling @emph{all} the code in your program.
(Note that @code{libf2c} is @emph{not} an example of code
-that is compiled using @code{f2c}---it is compiled by a C
-compiler, typically @code{gcc}.)
+that is compiled using @command{f2c}---it is compiled by a C
+compiler, typically @command{gcc}.)
@node Use Submodel Options
@subsection Use Submodel Options
@cindex submodels
-Using an appropriate @samp{-m} option to generate specific code for your
+Using an appropriate @option{-m} option to generate specific code for your
CPU may be worthwhile, though it may mean the executable won't run on
other versions of the CPU that don't support the same instruction set.
@xref{Submodel Options,,Hardware Models and Configurations,gcc,Using and
been built---as shown by @samp{g77 -v}---for the target
@samp{i386-pc-linux-gnu}, i.e.@: an @samp{i386} CPU@. In that case to
generate code best optimized for a Pentium you could use the option
-@samp{-march=pentium}.
+@option{-march=pentium}.
For recent CPUs that don't have explicit support in the released version
-of @code{gcc}, it @emph{might} still be possible to get improvements
-with certain @samp{-m} options.
+of @command{gcc}, it @emph{might} still be possible to get improvements
+with certain @option{-m} options.
-@samp{-fomit-frame-pointer} can help performance on x86 systems and
+@option{-fomit-frame-pointer} can help performance on x86 systems and
others. It will, however, inhibit debugging on the systems on which it
-is not turned on anyway by @samp{-O}.
+is not turned on anyway by @option{-O}.
@node Trouble
@chapter Known Causes of Trouble with GNU Fortran
@uref{ftp://alpha.gnu.org/g77.plan}.
(Note that some of this portion of the manual is lifted
-directly from the @code{gcc} manual, with minor modifications
-to tailor it to users of @code{g77}.
-Anytime a bug seems to have more to do with the @code{gcc}
-portion of @code{g77}, see
+directly from the @command{gcc} manual, with minor modifications
+to tailor it to users of @command{g77}.
+Anytime a bug seems to have more to do with the @command{gcc}
+portion of @command{g77}, see
@ref{Trouble,,Known Causes of Trouble with GNU CC,
gcc,Using and Porting GNU CC}.)
@menu
* But-bugs:: Bugs really in other programs or elsewhere.
-* Known Bugs:: Bugs known to be in this version of @code{g77}.
+* Known Bugs:: Bugs known to be in this version of @command{g77}.
* Missing Features:: Features we already know we want to add later.
* Disappointments:: Regrettable things we can't change.
* Non-bugs:: Things we think are right, but some others disagree.
@cindex but-bugs
These are bugs to which the maintainers often have to reply,
-``but that isn't a bug in @code{g77}@dots{}''.
+``but that isn't a bug in @command{g77}@dots{}''.
Some of these already are fixed in new versions of other
software; some still need to be fixed; some are problems
-with how @code{g77} is installed or is being used;
+with how @command{g77} is installed or is being used;
some are the result of bad hardware that causes software
to misbehave in sometimes bizarre ways;
some just cannot be addressed at this time until more
is known about the problem.
-Please don't re-report these bugs to the @code{g77} maintainers---if
+Please don't re-report these bugs to the @command{g77} maintainers---if
you must remind someone how important it is to you that the problem
be fixed, talk to the people responsible for the other products
identified below, but preferably only after you've tried the
latest versions of those products.
-The @code{g77} maintainers have their hands full working on
-just fixing and improving @code{g77}, without serving as a
-clearinghouse for all bugs that happen to affect @code{g77}
+The @command{g77} maintainers have their hands full working on
+just fixing and improving @command{g77}, without serving as a
+clearinghouse for all bugs that happen to affect @command{g77}
users.
@xref{Collected Fortran Wisdom}, for information on behavior
In particular, on systems other than those running the Linux
kernel, the message might appear somewhat or very different,
as it will if the error manifests itself while running a
-program other than the @code{g77} compiler.
+program other than the @command{g77} compiler.
For example,
it will appear somewhat different when running your program,
when running Emacs, and so on.
@cindex @code{ld}, error linking user code
@cindex @code{ld}, can't find strange names
On some systems, perhaps just those with out-of-date (shared?)
-libraries, unresolved-reference errors happen when linking @code{g77}-compiled
-programs (which should be done using @code{g77}).
+libraries, unresolved-reference errors happen when linking @command{g77}-compiled
+programs (which should be done using @command{g77}).
-If this happens to you, try appending @samp{-lc} to the command you
+If this happens to you, try appending @option{-lc} to the command you
use to link the program, e.g. @samp{g77 foo.f -lc}.
-@code{g77} already specifies @samp{-lg2c -lm} when it calls the linker,
-but it cannot also specify @samp{-lc} because not all systems have a
+@command{g77} already specifies @samp{-lg2c -lm} when it calls the linker,
+but it cannot also specify @option{-lc} because not all systems have a
file named @file{libc.a}.
It is unclear at this point whether there are legitimately installed
systems where @samp{-lg2c -lm} is insufficient to resolve code produced
-by @code{g77}.
+by @command{g77}.
@cindex undefined reference (_main)
@cindex linking error, user code
@cindex code, user
@cindex @code{ld}, can't find @samp{_main}
If your program doesn't link due to unresolved references to names
-like @samp{_main}, make sure you're using the @code{g77} command to do the
+like @samp{_main}, make sure you're using the @command{g77} command to do the
link, since this command ensures that the necessary libraries are
-loaded by specifying @samp{-lg2c -lm} when it invokes the @code{gcc}
+loaded by specifying @samp{-lg2c -lm} when it invokes the @command{gcc}
command to do the actual link.
-(Use the @samp{-v} option to discover
-more about what actually happens when you use the @code{g77} and @code{gcc}
+(Use the @option{-v} option to discover
+more about what actually happens when you use the @command{g77} and @command{gcc}
commands.)
-Also, try specifying @samp{-lc} as the last item on the @code{g77}
+Also, try specifying @option{-lc} as the last item on the @command{g77}
command line, in case that helps.
@node Large Common Blocks
@cindex @code{gdb}, support
@cindex support, @code{gdb}
There are some known problems when using @code{gdb} on code
-compiled by @code{g77}.
+compiled by @command{g77}.
Inadequate investigation as of the release of 0.5.16 results in not
knowing which products are the culprit, but @file{gdb-4.14} definitely
crashes when, for example, an attempt is made to print the contents
Attempts to access assumed-size arrays are
also known to crash recent versions of @code{gdb}.
(@code{gdb}'s Fortran support was done for a different compiler
-and isn't properly compatible with @code{g77}.)
+and isn't properly compatible with @command{g77}.)
@node NeXTStep Problems
@subsection NeXTStep Problems
@subsection Stack Overflow
@cindex stack, overflow
@cindex segmentation violation
-@code{g77} code might fail at runtime (probably with a ``segmentation
+@command{g77} code might fail at runtime (probably with a ``segmentation
violation'') due to overflowing the stack.
This happens most often on systems with an environment
that provides substantially more heap space (for use
changing some operating system or system configuration parameters.
You might be able to work around the problem by compiling with the
-@samp{-fno-automatic} option to reduce stack usage, probably at the
+@option{-fno-automatic} option to reduce stack usage, probably at the
expense of speed.
-@code{g77}, on most machines, puts many variables and arrays on the stack
+@command{g77}, on most machines, puts many variables and arrays on the stack
where possible, and can be configured (by changing
@code{FFECOM_sizeMAXSTACKITEM} in @file{@value{path-g77}/com.c}) to force
smaller-sized entities into static storage (saving
(for example, has declarations like @samp{REAL A(N)} where
@samp{A} is a local array and @samp{N} is a dummy or
@code{COMMON} variable that can have a large value),
-neither use of @samp{-fno-automatic},
-nor changing the cut-off point for @code{g77} for using the stack,
+neither use of @option{-fno-automatic},
+nor changing the cut-off point for @command{g77} for using the stack,
will solve the problem by changing the placement of these
large arrays, as they are @emph{necessarily} automatic.
-@code{g77} currently provides no means to specify that
+@command{g77} currently provides no means to specify that
automatic arrays are to be allocated on the heap instead
of the stack.
So, other than increasing the stack size, your best bet is to
@cindex bus error
@cindex overwritten data
@cindex data, overwritten
-@code{g77} code might fail at runtime with ``segmentation violation'',
+@command{g77} code might fail at runtime with ``segmentation violation'',
``bus error'', or even something as subtle as a procedure call
overwriting a variable or array element that it is not supposed
to touch.
Overflowing the bounds of an array---usually by writing beyond
the end of it---is one of two kinds of bug that often occurs
in Fortran code.
-(Compile your code with the @samp{-fbounds-check} option
+(Compile your code with the @option{-fbounds-check} option
to catch many of these kinds of errors at program run time.)
The other kind of bug is a mismatch between the actual arguments
data representing the placement of other data in memory (that is,
pointers, such as the placement of stack frames in memory).
-@code{g77} now offers the
+@command{g77} now offers the
ability to catch and report some of these problems at compile, link, or
run time, such as by generating code to detect references to
beyond the bounds of most arrays (except assumed-size arrays),
@cindex inconsistent floating-point results
@cindex results, inconsistent
Some programs appear to produce inconsistent floating-point
-results compiled by @code{g77} versus by other compilers.
+results compiled by @command{g77} versus by other compilers.
Often the reason for this behavior is the fact that floating-point
values are represented on almost all Fortran systems by
@emph{approximations}, and these approximations are inexact
even for apparently simple values like 0.1, 0.2, 0.3, 0.4, 0.6,
0.7, 0.8, 0.9, 1.1, and so on.
-Most Fortran systems, including all current ports of @code{g77},
+Most Fortran systems, including all current ports of @command{g77},
use binary arithmetic to represent these approximations.
Therefore, the exact value of any floating-point approximation
-as manipulated by @code{g77}-compiled code is representable by
+as manipulated by @command{g77}-compiled code is representable by
adding some combination of the values 1.0, 0.5, 0.25, 0.125, and
so on (just keep dividing by two) through the precision of the
fraction (typically around 23 bits for @code{REAL(KIND=1)}, 52 for
END
@end smallexample
-When compiled by @code{g77}, the above program might output
+When compiled by @command{g77}, the above program might output
@samp{0.20000003}, while another compiler might produce a
executable that outputs @samp{0.2}.
This particular difference is due to the fact that, currently,
conversion of floating-point values by the @code{libg2c} library,
-used by @code{g77}, handles only double-precision values.
+used by @command{g77}, handles only double-precision values.
Since @samp{0.2} in the program is a single-precision value, it
is converted to double precision (still in binary notation)
END
@end smallexample
-Future versions of @code{g77} and/or @code{libg2c} might convert
+Future versions of @command{g77} and/or @code{libg2c} might convert
single-precision values directly to decimal,
instead of converting them to double precision first.
This would tend to result in output that is more consistent
@cindex spills of floating-point results
@cindex 80-bit spills
@cindex truncation, of floating-point values
-(@emph{Note:} @code{g77} specifically, and @code{gcc} generally,
+(@emph{Note:} @command{g77} specifically, and @command{gcc} generally,
does arbitrarily truncate 80-bit results during spills
as of this writing.
It is not yet clear whether a future version of
@node Missing Features
@section Missing Features
-This section lists features we know are missing from @code{g77},
+This section lists features we know are missing from @command{g77},
and which we want to add someday.
(There is no priority implied in the ordering below.)
@node Better Source Model
@subsection Better Source Model
-@code{g77} needs to provide, as the default source-line model,
+@command{g77} needs to provide, as the default source-line model,
a ``pure visual'' mode, where
the interpretation of a source program in this mode can be accurately
determined by a user looking at a traditionally displayed rendition
they would end at column 72 just as if the tabs were replaced
by spaces in the canonical way.
-As part of this, provide common alternate models (Digital, @code{f2c},
+As part of this, provide common alternate models (Digital, @command{f2c},
and so on) via command-line options.
This includes allowing arbitrarily long
lines for free-form source as well as fixed-form source and providing
@cindex sequence numbers
@cindex columns 73 through 80
-Also, @code{g77} should offer, perhaps even default to, warnings
+Also, @command{g77} should offer, perhaps even default to, warnings
when characters beyond the last valid column are anything other
than spaces.
This would mean code with ``sequence numbers'' in columns 73 through 80
accidentally writing fixed-form source code into and beyond
column 73.
So, maybe the users of old code would be able to more easily handle
-having to specify, say, a @samp{-Wno-col73to80} option.
+having to specify, say, a @option{-Wno-col73to80} option.
@node Fortran 90 Support
@subsection Fortran 90 Support
@cindex Fortran 90, support
@cindex support, Fortran 90
-@code{g77} does not support many of the features that
+@command{g77} does not support many of the features that
distinguish Fortran 90 (and, now, Fortran 95) from
ANSI FORTRAN 77.
make sense to offer even to die-hard users of F77.
For example, many of them codify various ways F77 has
been extended to meet users' needs during its tenure,
-so @code{g77} might as well offer them as the primary
+so @command{g77} might as well offer them as the primary
way to meet those same needs, even if it offers compatibility
with one or more of the ways those needs were met
by other F77 compilers in the industry.
Still, many important F90 features are not supported,
because no attempt has been made to research each and
-every feature and assess its viability in @code{g77}.
+every feature and assess its viability in @command{g77}.
In the meantime, users who need those features must
use Fortran 90 compilers anyway, and the best approach
to adding some F90 features to GNU Fortran might well be
@cindex PARAMETER statement
@cindex statements, PARAMETER
-@code{g77} doesn't allow intrinsics in @code{PARAMETER} statements.
+@command{g77} doesn't allow intrinsics in @code{PARAMETER} statements.
This feature is considered to be absolutely vital, even though it
is not standard-conforming, and is scheduled for version 0.6.
-Related to this, @code{g77} doesn't allow non-integral
+Related to this, @command{g77} doesn't allow non-integral
exponentiation in @code{PARAMETER} statements, such as
@samp{PARAMETER (R=2**.25)}.
-It is unlikely @code{g77} will ever support this feature,
+It is unlikely @command{g77} will ever support this feature,
as doing it properly requires complete emulation of
a target computer's floating-point facilities when
-building @code{g77} as a cross-compiler.
-But, if the @code{gcc} back end is enhanced to provide
-such a facility, @code{g77} will likely use that facility
+building @command{g77} as a cross-compiler.
+But, if the @command{gcc} back end is enhanced to provide
+such a facility, @command{g77} will likely use that facility
in implementing this feature soon afterwards.
@node Arbitrary Concatenation
@cindex CHARACTER*(*)
@cindex run-time, dynamic allocation
-@code{g77} doesn't support arbitrary operands for concatenation
+@command{g77} doesn't support arbitrary operands for concatenation
in contexts where run-time allocation is required.
For example:
@cindex recursion, lack of
@cindex lack of recursion
-@code{g77} doesn't support the @code{RECURSIVE} keyword that
+@command{g77} doesn't support the @code{RECURSIVE} keyword that
F90 compilers do.
Nor does it provide any means for compiling procedures
designed to do recursion.
@cindex Toolpack
@cindex Netlib
-Some compilers, such as @code{f2c}, have an option (@samp{-r8},
-@samp{-qrealsize=8} or
+Some compilers, such as @command{f2c}, have an option (@option{-r8},
+@option{-qrealsize=8} or
similar) that provides automatic treatment of @code{REAL}
entities such that they have twice the storage size, and
a corresponding increase in the range and precision, of what
would normally be the @code{REAL(KIND=1)} (default @code{REAL}) type.
(This affects @code{COMPLEX} the same way.)
-They also typically offer another option (@samp{-i8}) to increase
+They also typically offer another option (@option{-i8}) to increase
@code{INTEGER} entities so they are twice as large
(with roughly twice as much range).
(There are potential pitfalls in using these options.)
-@code{g77} does not yet offer any option that performs these
+@command{g77} does not yet offer any option that performs these
kinds of transformations.
Part of the problem is the lack of detailed specifications regarding
exactly how these options affect the interpretation of constants,
intrinsics, and so on.
-Until @code{g77} addresses this need, programmers could improve
+Until @command{g77} addresses this need, programmers could improve
the portability of their code by modifying it to not require
compile-time options to produce correct results.
Some free tools are available which may help, specifically
@cindex @code{LOGICAL*1} support
@cindex types, @code{LOGICAL*1}
-@code{g77} doesn't fully support @code{INTEGER*2}, @code{LOGICAL*1},
+@command{g77} doesn't fully support @code{INTEGER*2}, @code{LOGICAL*1},
and similar.
Version 0.6 will provide full support for this very
popular set of features.
@cindex types, @code{REAL*16}
@cindex @code{INTEGER*8} support
@cindex types, @code{INTEGER*8}
-@code{g77} doesn't support @code{INTEGER}, @code{REAL}, and @code{COMPLEX} equivalents
+@command{g77} doesn't support @code{INTEGER}, @code{REAL}, and @code{COMPLEX} equivalents
for @emph{all} applicable back-end-supported types (@code{char}, @code{short int},
@code{int}, @code{long int}, @code{long long int}, and @code{long double}).
This means providing intrinsic support, and maybe constant
@cindex @code{DIMENSION} statement
@cindex statements, @code{DIMENSION}
-@code{g77} doesn't support more general expressions to dimension
+@command{g77} doesn't support more general expressions to dimension
arrays, such as array element references, function
references, etc.
-For example, @code{g77} currently does not accept the following:
+For example, @command{g77} currently does not accept the following:
@smallexample
SUBROUTINE X(M, N)
@cindex statements, POINTER
@cindex Cray pointers
-@code{g77} doesn't support pointers or allocatable objects
+@command{g77} doesn't support pointers or allocatable objects
(other than automatic arrays).
This set of features is
probably considered just behind intrinsics
in @code{PARAMETER} statements on the list of large,
-important things to add to @code{g77}.
+important things to add to @command{g77}.
In the meantime, consider using the @code{INTEGER(KIND=7)}
declaration to specify that a variable must be
able to hold a pointer.
This construct is not portable to other non-GNU compilers,
but it is portable to all machines GNU Fortran supports
-when @code{g77} is used.
+when @command{g77} is used.
@xref{Functions and Subroutines}, for information on
@code{%VAL()}, @code{%REF()}, and @code{%DESCR()}
@node Sensible Non-standard Constructs
@subsection Sensible Non-standard Constructs
-@code{g77} rejects things other compilers accept,
+@command{g77} rejects things other compilers accept,
like @samp{INTRINSIC SQRT,SQRT}.
As time permits in the future, some of these things that are easy for
humans to read and write and unlikely to be intended to mean something
-else will be accepted by @code{g77} (though @samp{-fpedantic} should
+else will be accepted by @command{g77} (though @option{-fpedantic} should
trigger warnings about such non-standard constructs).
-Until @code{g77} no longer gratuitously rejects sensible code,
+Until @command{g77} no longer gratuitously rejects sensible code,
you might as well fix your code
to be more standard-conforming and portable.
to indicate that all local variables and arrays are to
have the @code{SAVE} attribute.
-For this reason, @code{g77} already has been changed to
+For this reason, @command{g77} already has been changed to
allow this combination, because although the general
problem of gratuitously rejecting unambiguous and
-``safe'' constructs still exists in @code{g77}, this
+``safe'' constructs still exists in @command{g77}, this
particular construct was deemed useful enough that
-it was worth fixing @code{g77} for just this case.
+it was worth fixing @command{g77} for just this case.
So, while there is no need to change your code
to avoid using this particular construct, there
might be other, equally appropriate but non-standard
constructs, that you shouldn't have to stop using
-just because @code{g77} (or any other compiler)
+just because @command{g77} (or any other compiler)
gratuitously rejects it.
Until the general problem is solved, if you have
using (e.g. not just an arbitrary, redundant
specification of an attribute), please submit a
bug report with an explanation, so we can consider
-fixing @code{g77} just for cases like yours.
+fixing @command{g77} just for cases like yours.
@node READONLY Keyword
@subsection @code{READONLY} Keyword
if a @code{WRITE} or @code{PRINT}
to such a unit is attempted.
-@emph{Note:} It is not sufficient for @code{g77} and @code{libg2c}
+@emph{Note:} It is not sufficient for @command{g77} and @code{libg2c}
(its version of @code{libf2c})
to assume that @code{READONLY} does not need some kind of explicit support
at run time,
due to UNIX systems not (generally) needing it.
-@code{g77} is not just a UNIX-based compiler!
+@command{g77} is not just a UNIX-based compiler!
Further, mounting of non-UNIX filesystems on UNIX systems
(such as via NFS)
@node FLUSH Statement
@subsection @code{FLUSH} Statement
-@code{g77} could perhaps use a @code{FLUSH} statement that
+@command{g77} could perhaps use a @code{FLUSH} statement that
does what @samp{CALL FLUSH} does,
but that supports @samp{*} as the unit designator (same unit as for
@code{PRINT}) and accepts @code{ERR=} and/or @code{IOSTAT=}
@cindex FORMAT statement
@cindex statements, FORMAT
-@code{g77} doesn't support @samp{FORMAT(I<J>)} and the like.
+@command{g77} doesn't support @samp{FORMAT(I<J>)} and the like.
Supporting this requires a significant redesign or replacement
of @code{libg2c}.
-However, @code{g77} does support
+However, @command{g77} does support
this construct when the expression is constant
(as of version 0.5.22).
For example:
@node Explicit Assembler Code
@subsection Explicit Assembler Code
-@code{g77} needs to provide some way, a la @code{gcc}, for @code{g77}
+@command{g77} needs to provide some way, a la @command{gcc}, for @command{g77}
code to specify explicit assembler code.
@node Q Edit Descriptor
@cindex PARAMETER statement
@cindex statements, PARAMETER
-@code{g77} doesn't accept @samp{PARAMETER I=1}.
+@command{g77} doesn't accept @samp{PARAMETER I=1}.
Supporting this obsolete form of
the @code{PARAMETER} statement would not be particularly hard, as most of the
parsing code is already in place and working.
@cindex ACCEPT statement
@cindex statements, ACCEPT
-@code{g77} doesn't support the I/O statements @code{TYPE} and
+@command{g77} doesn't support the I/O statements @code{TYPE} and
@code{ACCEPT}.
These are common extensions that should be easy to support,
but also are fairly easy to work around in user code.
@cindex MAP statement
@cindex statements, MAP
-@code{g77} doesn't support @code{STRUCTURE}, @code{UNION}, @code{RECORD},
+@command{g77} doesn't support @code{STRUCTURE}, @code{UNION}, @code{RECORD},
@code{MAP}.
This set of extensions is quite a bit
-lower on the list of large, important things to add to @code{g77}, partly
+lower on the list of large, important things to add to @command{g77}, partly
because it requires a great deal of work either upgrading or
replacing @code{libg2c}.
@cindex INQUIRE statement
@cindex statements, INQUIRE
-@code{g77} doesn't have support for keywords such as @code{DISP='DELETE'} in
+@command{g77} doesn't have support for keywords such as @code{DISP='DELETE'} in
the @code{OPEN}, @code{CLOSE}, and @code{INQUIRE} statements.
-These extensions are easy to add to @code{g77} itself, but
+These extensions are easy to add to @command{g77} itself, but
require much more work on @code{libg2c}.
@cindex FORM='PRINT'
@cindex carriage control
@pindex asa
@pindex fpr
-@code{g77} doesn't support @code{FORM='PRINT'} or an equivalent to
+@command{g77} doesn't support @code{FORM='PRINT'} or an equivalent to
translate the traditional `carriage control' characters in column 1 of
output to use backspaces, carriage returns and the like. However
programs exist to translate them in output files (or standard output).
@cindex DECODE statement
@cindex statements, DECODE
-@code{g77} doesn't support @code{ENCODE} or @code{DECODE}.
+@command{g77} doesn't support @code{ENCODE} or @code{DECODE}.
These statements are best replaced by READ and WRITE statements
involving internal files (CHARACTER variables and arrays).
@end smallexample
It is entirely possible that @code{ENCODE} and @code{DECODE} will
-be supported by a future version of @code{g77}.
+be supported by a future version of @command{g77}.
@node AUTOMATIC Statement
@subsection @code{AUTOMATIC} Statement
@cindex automatic variables
@cindex variables, automatic
-@code{g77} doesn't support the @code{AUTOMATIC} statement that
-@code{f2c} does.
+@command{g77} doesn't support the @code{AUTOMATIC} statement that
+@command{f2c} does.
@code{AUTOMATIC} would identify a variable or array
as not being @code{SAVE}'d, which is normally the default,
but which would be especially useful for code that, @emph{generally},
-needed to be compiled with the @samp{-fno-automatic} option.
+needed to be compiled with the @option{-fno-automatic} option.
@code{AUTOMATIC} also would serve as a hint to the compiler that placing
the variable or array---even a very large array--on the stack is acceptable.
@node Suppressing Space Padding
@subsection Suppressing Space Padding of Source Lines
-@code{g77} should offer VXT-Fortran-style suppression of virtual
+@command{g77} should offer VXT-Fortran-style suppression of virtual
spaces at the end of a source line
if an appropriate command-line option is specified.
@end smallexample
@noindent
-@code{g77}, and many other compilers, virtually extend
+@command{g77}, and many other compilers, virtually extend
the continued line through column 72 with spaces that become part
of the character constant, but Digital Fortran normally didn't,
leaving only one space between @samp{MANY} and @samp{SPACES?}
from readers of the USENET group @file{comp.lang.fortran}
to offer conformance to this widespread practice in the
industry.
-@code{g77} should return the favor by offering conformance
+@command{g77} should return the favor by offering conformance
to Digital's approach to handling the above example.
@node Fortran Preprocessor
@subsection Fortran Preprocessor
-@code{g77} should offer a preprocessor designed specifically
+@command{g77} should offer a preprocessor designed specifically
for Fortran to replace @samp{cpp -traditional}.
There are several out there worth evaluating, at least.
@cindex @code{Shift} intrinsic
@cindex intrinsics, @code{Shift}
-@code{g77} does not allow @code{REAL} and other non-integral types for
+@command{g77} does not allow @code{REAL} and other non-integral types for
arguments to intrinsics like @code{And}, @code{Or}, and @code{Shift}.
-For example, this program is rejected by @code{g77}, because
+For example, this program is rejected by @command{g77}, because
the intrinsic @code{Iand} does not accept @code{REAL} arguments:
@smallexample
@node Really Ugly Character Assignments
@subsection Really Ugly Character Assignments
-An option such as @samp{-fugly-char} should be provided
+An option such as @option{-fugly-char} should be provided
to allow
@smallexample
@node POSIX Standard
@subsection @code{POSIX} Standard
-@code{g77} should support the POSIX standard for Fortran.
+@command{g77} should support the POSIX standard for Fortran.
@node Floating-point Exception Handling
@subsection Floating-point Exception Handling
@cindex FPE handling
@cindex NaN values
-The @code{gcc} backend and, consequently, @code{g77}, currently provides no
+The @command{gcc} backend and, consequently, @command{g77}, currently provides no
general control over whether or not floating-point exceptions are trapped or
ignored.
(Ignoring them typically results in NaN values being
options which change the behaviour.
Most systems provide some C-callable mechanism to change this; this can
-be invoked at startup using @code{gcc}'s @code{constructor} attribute.
+be invoked at startup using @command{gcc}'s @code{constructor} attribute.
For example, just compiling and linking the following C code with your
program will turn on exception trapping for the ``common'' exceptions
on a GNU system using glibc 2.2 or newer:
@smallexample
gcc -o libtrapfpe.a trapfpe.c
@end smallexample
-and then use it by adding @samp{-trapfpe} to the @code{g77} command line
+and then use it by adding @option{-trapfpe} to the @command{g77} command line
when linking.
@node Nonportable Conversions
@cindex nonportable conversions
@cindex conversions, nonportable
-@code{g77} doesn't accept some particularly nonportable,
+@command{g77} doesn't accept some particularly nonportable,
silent data-type conversions such as @code{LOGICAL}
to @code{REAL} (as in @samp{A=.FALSE.}, where @samp{A}
is type @code{REAL}), that other compilers might
quietly accept.
-Some of these conversions are accepted by @code{g77}
-when the @samp{-fugly-logint} option is specified.
+Some of these conversions are accepted by @command{g77}
+when the @option{-fugly-logint} option is specified.
Perhaps it should accept more or all of them.
@node Large Automatic Arrays
Currently, automatic arrays always are allocated on the stack.
For situations where the stack cannot be made large enough,
-@code{g77} should offer a compiler option that specifies
+@command{g77} should offer a compiler option that specifies
allocation of automatic arrays in heap storage.
@node Support for Threads
@cindex threads
@cindex parallel processing
-Neither the code produced by @code{g77} nor the @code{libg2c} library
-are thread-safe, nor does @code{g77} have support for parallel processing
+Neither the code produced by @command{g77} nor the @code{libg2c} library
+are thread-safe, nor does @command{g77} have support for parallel processing
(other than the instruction-level parallelism available on some
processors).
A package such as PVM might help here.
@cindex debug line
@cindex comment line, debug
-An option such as @samp{-fdebug-lines} should be provided
+An option such as @option{-fdebug-lines} should be provided
to turn fixed-form lines beginning with @samp{D}
to be treated as if they began with a space,
instead of as if they began with a @samp{C}
@node Better Warnings
@subsection Better Warnings
-Because of how @code{g77} generates code via the back end,
+Because of how @command{g77} generates code via the back end,
it doesn't always provide warnings the user wants.
Consider:
Currently, the above is not flagged as a case of
using an uninitialized variable,
-because @code{g77} generates a run-time library call that looks,
+because @command{g77} generates a run-time library call that looks,
to the GBE, like it might actually @emph{modify} @samp{A} at run time.
(And, in fact, depending on the previous run-time library call,
it would!)
for some types of code.
@item
-Have @code{g77} pass a pointer to a temporary
+Have @command{g77} pass a pointer to a temporary
containing a copy of @samp{A},
instead of to @samp{A} itself.
The GBE would then complain about the copy operation
which could help with inner loops.
@item
-Have @code{g77} use a GBE construct similar to @code{ADDR_EXPR}
+Have @command{g77} use a GBE construct similar to @code{ADDR_EXPR}
but with extra information on the fact that the
item pointed to won't be modified
(a la @code{const} in C).
Probably the best solution for now, but not quite trivial
to implement in the general case.
-Worth considering after @code{g77} 0.6 is considered
+Worth considering after @command{g77} 0.6 is considered
pretty solid.
@end itemize
@node Gracefully Handle Sensible Bad Code
@subsection Gracefully Handle Sensible Bad Code
-@code{g77} generally should continue processing for
+@command{g77} generally should continue processing for
warnings and recoverable (user) errors whenever possible---that
is, it shouldn't gratuitously make bad or useless code.
@end smallexample
@noindent
-When compiling the above with @samp{-ff2c-intrinsics-disable},
-@code{g77} should indeed complain about passing @code{ZABS},
+When compiling the above with @option{-ff2c-intrinsics-disable},
+@command{g77} should indeed complain about passing @code{ZABS},
but it still should compile, instead of rejecting
the entire @code{CALL} statement.
(Some of this is related to improving
@node Non-standard Conversions
@subsection Non-standard Conversions
-@samp{-Wconversion} and related should flag places where non-standard
+@option{-Wconversion} and related should flag places where non-standard
conversions are found.
-Perhaps much of this would be part of @samp{-Wugly*}.
+Perhaps much of this would be part of @option{-Wugly*}.
@node Non-standard Intrinsics
@subsection Non-standard Intrinsics
-@code{g77} needs a new option, like @samp{-Wintrinsics}, to warn about use of
+@command{g77} needs a new option, like @option{-Wintrinsics}, to warn about use of
non-standard intrinsics without explicit @code{INTRINSIC} statements for them.
This would help find code that might fail silently when ported to another
compiler.
@node Modifying DO Variable
@subsection Modifying @code{DO} Variable
-@code{g77} should warn about modifying @code{DO} variables
+@command{g77} should warn about modifying @code{DO} variables
via @code{EQUIVALENCE}.
(The internal information gathered to produce this warning
might also be useful in setting the
internal ``doiter'' flag for a variable or even array
reference within a loop, since that might produce faster code someday.)
-For example, this code is invalid, so @code{g77} should warn about
+For example, this code is invalid, so @command{g77} should warn about
the invalid assignment to @samp{NOTHER}:
@smallexample
@node Better Pedantic Compilation
@subsection Better Pedantic Compilation
-@code{g77} needs to support @samp{-fpedantic} more thoroughly,
+@command{g77} needs to support @option{-fpedantic} more thoroughly,
and use it only to generate
warnings instead of rejecting constructs outright.
Have it warn:
@node Warn About Implicit Conversions
@subsection Warn About Implicit Conversions
-@code{g77} needs a @samp{-Wpromotions} option to warn if source code appears
+@command{g77} needs a @option{-Wpromotions} option to warn if source code appears
to expect automatic, silent, and
somewhat dangerous compiler-assisted conversion of @code{REAL(KIND=1)}
constants to @code{REAL(KIND=2)} based on context.
@node Invalid Use of Hollerith Constant
@subsection Invalid Use of Hollerith Constant
-@code{g77} should disallow statements like @samp{RETURN 2HAB},
+@command{g77} should disallow statements like @samp{RETURN 2HAB},
which are invalid in both source forms
(unlike @samp{RETURN (2HAB)},
which probably still makes no sense but at least can
@node Dummy Array Without Dimensioning Dummy
@subsection Dummy Array Without Dimensioning Dummy
-@code{g77} should complain when a list of dummy arguments containing an
+@command{g77} should complain when a list of dummy arguments containing an
adjustable dummy array does
not also contain every variable listed in the dimension list of the
adjustable array.
-Currently, @code{g77} does complain about a variable that
+Currently, @command{g77} does complain about a variable that
dimensions an array but doesn't appear in any dummy list or @code{COMMON}
area, but this needs to be extended to catch cases where it doesn't appear in
every dummy list that also lists any arrays it dimensions.
-For example, @code{g77} should warn about the entry point @samp{ALT}
+For example, @command{g77} should warn about the entry point @samp{ALT}
below, since it includes @samp{ARRAY} but not @samp{ISIZE} in its
list of arguments:
@node Invalid FORMAT Specifiers
@subsection Invalid FORMAT Specifiers
-@code{g77} should check @code{FORMAT} specifiers for validity
+@command{g77} should check @code{FORMAT} specifiers for validity
as it does @code{FORMAT} statements.
For example, a diagnostic would be produced for:
@node Ambiguous Dialects
@subsection Ambiguous Dialects
-@code{g77} needs a set of options such as @samp{-Wugly*}, @samp{-Wautomatic},
-@samp{-Wvxt}, @samp{-Wf90}, and so on.
+@command{g77} needs a set of options such as @option{-Wugly*}, @option{-Wautomatic},
+@option{-Wvxt}, @option{-Wf90}, and so on.
These would warn about places in the user's source where ambiguities
are found, helpful in resolving ambiguities in the program's
dialect or dialects.
@node Unused Labels
@subsection Unused Labels
-@code{g77} should warn about unused labels when @samp{-Wunused} is in effect.
+@command{g77} should warn about unused labels when @option{-Wunused} is in effect.
@node Informational Messages
@subsection Informational Messages
-@code{g77} needs an option to suppress information messages (notes).
-@samp{-w} does this but also suppresses warnings.
+@command{g77} needs an option to suppress information messages (notes).
+@option{-w} does this but also suppresses warnings.
The default should be to suppress info messages.
Perhaps info messages should simply be eliminated.
@node Uninitialized Variables at Run Time
@subsection Uninitialized Variables at Run Time
-@code{g77} needs an option to initialize everything (not otherwise
+@command{g77} needs an option to initialize everything (not otherwise
explicitly initialized) to ``weird''
(machine-dependent) values, e.g. NaNs, bad (non-@code{NULL}) pointers, and
largest-magnitude integers, would help track down references to
@cindex file formats
@cindex binary data
@cindex byte ordering
-@code{g77} has no facility for exchanging unformatted files with systems
+@command{g77} has no facility for exchanging unformatted files with systems
using different number formats---even differing only in endianness (byte
order)---or written by other compilers. Some compilers provide
facilities at least for doing byte-swapping during unformatted I/O.
It is unrealistic to expect to cope with exchanging unformatted files
-with arbitrary other compiler runtimes, but the @code{g77} runtime
-should at least be able to read files written by @code{g77} on systems
+with arbitrary other compiler runtimes, but the @command{g77} runtime
+should at least be able to read files written by @command{g77} on systems
with different number formats, particularly if they differ only in byte
order.
In case you do need to write a program to translate to or from
-@code{g77} (@code{libf2c}) unformatted files, they are written as
+@command{g77} (@code{libf2c}) unformatted files, they are written as
follows:
@table @asis
@item Sequential
point it would be sufficient to reverse the bytes in consecutive words
in the file if, and @emph{only} if, only @code{REAL*4}, @code{COMPLEX},
@code{INTEGER*4} and/or @code{LOGICAL*4} data have been written to it by
-@code{g77}.
+@command{g77}.
-If necessary, it is possible to do byte-oriented i/o with @code{g77}'s
+If necessary, it is possible to do byte-oriented i/o with @command{g77}'s
@code{FGETC} and @code{FPUTC} intrinsics. Byte-swapping can be done in
Fortran by equivalencing larger sized variables to an @code{INTEGER*1}
array or a set of scalars.
(@uref{http://www.llnl.gov/def_sci/pact/pact_homepage.html}). (Unlike,
say, CDF or XDR, HDF-like systems write in the native number formats and
only incur overhead when they are read on a system with a different
-format.) A future @code{g77} runtime library should use such
+format.) A future @command{g77} runtime library should use such
techniques.
@node Better List-directed I/O
In the meantime, use of formatted I/O is recommended.
While it might be of little consolation,
-@code{g77} does support @samp{FORMAT(F<WIDTH>.4)}, for example,
+@command{g77} does support @samp{FORMAT(F<WIDTH>.4)}, for example,
as long as @samp{WIDTH} is defined as a named constant
(via @code{PARAMETER}).
That at least allows some compile-time specification
@node Labels Visible to Debugger
@subsection Labels Visible to Debugger
-@code{g77} should output debugging information for statements labels,
+@command{g77} should output debugging information for statements labels,
for use by debuggers that know how to support them.
Same with weirder things like construct names.
It is not yet known if any debug formats or debuggers support these.
@cindex statements, @code{COMMON}
@cindex naming conflicts
-@code{g77} doesn't allow a common block and an external procedure or
+@command{g77} doesn't allow a common block and an external procedure or
@code{BLOCK DATA} to have the same name.
-Some systems allow this, but @code{g77} does not,
-to be compatible with @code{f2c}.
+Some systems allow this, but @command{g77} does not,
+to be compatible with @command{f2c}.
-@code{g77} could special-case the way it handles
-@code{BLOCK DATA}, since it is not compatible with @code{f2c} in this
-particular area (necessarily, since @code{g77} offers an
+@command{g77} could special-case the way it handles
+@code{BLOCK DATA}, since it is not compatible with @command{f2c} in this
+particular area (necessarily, since @command{g77} offers an
important feature here), but
it is likely that such special-casing would be very annoying to people
with programs that use @samp{EXTERNAL FOO}, with no other mention of
@samp{FOO} in the same program unit, to refer to external procedures, since
-the result would be that @code{g77} would treat these references as requests to
+the result would be that @command{g77} would treat these references as requests to
force-load BLOCK DATA program units.
-In that case, if @code{g77} modified
+In that case, if @command{g77} modified
names of @code{BLOCK DATA} so they could have the same names as
@code{COMMON}, users
would find that their programs wouldn't link because the @samp{FOO} procedure
didn't have its name translated the same way.
(Strictly speaking,
-@code{g77} could emit a null-but-externally-satisfying definition of
+@command{g77} could emit a null-but-externally-satisfying definition of
@samp{FOO} with its name transformed as if it had been a
@code{BLOCK DATA}, but that probably invites more trouble than it's
worth.)
@cindex IMPLICIT CHARACTER*(*) statement
@cindex statements, IMPLICIT CHARACTER*(*)
-@code{g77} disallows @code{IMPLICIT CHARACTER*(*)}.
+@command{g77} disallows @code{IMPLICIT CHARACTER*(*)}.
This is not standard-conforming.
@node Non-bugs
@cindex support, @code{f77}
In the opinion of many experienced Fortran users,
-@samp{-fno-backslash} should be the default, not @samp{-fbackslash},
-as currently set by @code{g77}.
+@option{-fno-backslash} should be the default, not @option{-fbackslash},
+as currently set by @command{g77}.
First of all, you can always specify
-@samp{-fno-backslash} to turn off this processing.
+@option{-fno-backslash} to turn off this processing.
Despite not being within the spirit (though apparently within the
-letter) of the ANSI FORTRAN 77 standard, @code{g77} defaults to
-@samp{-fbackslash} because that is what most UNIX @code{f77} commands
+letter) of the ANSI FORTRAN 77 standard, @command{g77} defaults to
+@option{-fbackslash} because that is what most UNIX @code{f77} commands
default to, and apparently lots of code depends on this feature.
This is a particularly troubling issue.
is bad enough, worse when it makes existing Fortran
programs stop working (as happens when programs written
for non-UNIX systems are ported to UNIX systems with
-compilers that provide the @samp{-fbackslash} feature
+compilers that provide the @option{-fbackslash} feature
as the default---sometimes with no option to turn it off).
The author of GNU Fortran wished, for reasons of linguistic
-purity, to make @samp{-fno-backslash} the default for GNU
-Fortran and thus require users of UNIX @code{f77} and @code{f2c}
-to specify @samp{-fbackslash} to get the UNIX behavior.
+purity, to make @option{-fno-backslash} the default for GNU
+Fortran and thus require users of UNIX @code{f77} and @command{f2c}
+to specify @option{-fbackslash} to get the UNIX behavior.
-However, the realization that @code{g77} is intended as
+However, the realization that @command{g77} is intended as
a replacement for @emph{UNIX} @code{f77}, caused the author
-to choose to make @code{g77} as compatible with
-@code{f77} as feasible, which meant making @samp{-fbackslash}
+to choose to make @command{g77} as compatible with
+@code{f77} as feasible, which meant making @option{-fbackslash}
the default.
The primary focus on compatibility is at the source-code
level, and the question became ``What will users expect
a replacement for @code{f77} to do, by default?''
Although at least one UNIX @code{f77} does not provide
-@samp{-fbackslash} as a default, it appears that
+@option{-fbackslash} as a default, it appears that
the majority of them do, which suggests that
the majority of code that is compiled by UNIX @code{f77}
-compilers expects @samp{-fbackslash} to be the default.
+compilers expects @option{-fbackslash} to be the default.
It is probably the case that more code exists
-that would @emph{not} work with @samp{-fbackslash}
+that would @emph{not} work with @option{-fbackslash}
in force than code that requires it be in force.
However, most of @emph{that} code is not being compiled
they work under UNIX.
That makes a much more natural and safe opportunity for
non-UNIX users to adapt their build procedures for
-@code{g77}'s default of @samp{-fbackslash} than would
+@command{g77}'s default of @option{-fbackslash} than would
exist for the majority of UNIX @code{f77} users who
would have to modify existing, working build procedures
-to explicitly specify @samp{-fbackslash} if that was
+to explicitly specify @option{-fbackslash} if that was
not the default.
One suggestion has been to configure the default for
-@samp{-fbackslash} (and perhaps other options as well)
-based on the configuration of @code{g77}.
+@option{-fbackslash} (and perhaps other options as well)
+based on the configuration of @command{g77}.
This is technically quite straightforward, but will be avoided
even in cases where not configuring defaults to be
And users writing a
program to run on more than one type of machine cannot possibly benefit
from this kind of compatibility.
-(This is consistent with the design goals for @code{gcc}.
-To change them for @code{g77}, you must first change them
-for @code{gcc}.
-Do not ask the maintainers of @code{g77} to do this for you,
-or to disassociate @code{g77} from the widely understood, if
+(This is consistent with the design goals for @command{gcc}.
+To change them for @command{g77}, you must first change them
+for @command{gcc}.
+Do not ask the maintainers of @command{g77} to do this for you,
+or to disassociate @command{g77} from the widely understood, if
not widely agreed-upon, goals for GNU compilers in general.)
This is why GNU Fortran does and will treat backslashes in the same
@cindex initialization, statement placement
@cindex placing initialization statements
-@code{g77} does not allow @samp{DATA VAR/1/} to appear in the
+@command{g77} does not allow @samp{DATA VAR/1/} to appear in the
source code before @samp{COMMON VAR},
@samp{DIMENSION VAR(10)}, @samp{INTEGER VAR}, and so on.
-In general, @code{g77} requires initialization of a variable
+In general, @command{g77} requires initialization of a variable
or array to be specified @emph{after} all other specifications
of attributes (type, size, placement, and so on) of that variable
or array are specified (though @emph{confirmation} of data type is
permitted).
-It is @emph{possible} @code{g77} will someday allow all of this,
+It is @emph{possible} @command{g77} will someday allow all of this,
even though it is not allowed by the FORTRAN 77 standard.
Then again, maybe it is better to have
-@code{g77} always require placement of @code{DATA}
+@command{g77} always require placement of @code{DATA}
so that it can possibly immediately write constants
to the output file, thus saving time and space.
@cindex intrinsics, context-sensitive
@cindex context-sensitive intrinsics
-@code{g77} treats procedure references to @emph{possible} intrinsic
+@command{g77} treats procedure references to @emph{possible} intrinsic
names as always enabling their intrinsic nature, regardless of
whether the @emph{form} of the reference is valid for that
intrinsic.
-For example, @samp{CALL SQRT} is interpreted by @code{g77} as
+For example, @samp{CALL SQRT} is interpreted by @command{g77} as
an invalid reference to the @code{SQRT} intrinsic function,
because the reference is a subroutine invocation.
-First, @code{g77} recognizes the statement @samp{CALL SQRT}
+First, @command{g77} recognizes the statement @samp{CALL SQRT}
as a reference to a @emph{procedure} named @samp{SQRT}, not
to a @emph{variable} with that name (as it would for a statement
such as @samp{V = SQRT}).
-Next, @code{g77} establishes that, in the program unit being compiled,
+Next, @command{g77} establishes that, in the program unit being compiled,
@code{SQRT} is an intrinsic---not a subroutine that
happens to have the same name as an intrinsic (as would be
the case if, for example, @samp{EXTERNAL SQRT} was present).
-Finally, @code{g77} recognizes that the @emph{form} of the
+Finally, @command{g77} recognizes that the @emph{form} of the
reference is invalid for that particular intrinsic.
That is, it recognizes that it is invalid for an intrinsic
@emph{function}, such as @code{SQRT}, to be invoked as
a @emph{subroutine}.
-At that point, @code{g77} issues a diagnostic.
+At that point, @command{g77} issues a diagnostic.
Some users claim that it is ``obvious'' that @samp{CALL SQRT}
references an external subroutine of their own, not an
intrinsic function.
-However, @code{g77} knows about intrinsic
+However, @command{g77} knows about intrinsic
subroutines, not just functions, and is able to support both having
the same names, for example.
-As a result of this, @code{g77} rejects calls
+As a result of this, @command{g77} rejects calls
to intrinsics that are not subroutines, and function invocations
of intrinsics that are not functions, just as it (and most compilers)
rejects invocations of intrinsics with the wrong number (or types)
@cindex constants, context-sensitive
@cindex context-sensitive constants
-@code{g77} does not use context to determine the types of
+@command{g77} does not use context to determine the types of
constants or named constants (@code{PARAMETER}), except
for (non-standard) typeless constants such as @samp{'123'O}.
@end smallexample
@noindent
-@code{g77} will interpret the (truncated) constant
+@command{g77} will interpret the (truncated) constant
@samp{9.435784839284958} as a @code{REAL(KIND=1)}, not @code{REAL(KIND=2)},
constant, because the suffix @code{D0} is not specified.
As a result, the output of the above statement when
-compiled by @code{g77} will appear to have ``less precision''
+compiled by @command{g77} will appear to have ``less precision''
than when compiled by other compilers.
In these and other cases, some compilers detect the
Running the above program should
result in the same value being
printed three times.
-With @code{g77} as the compiler,
+With @command{g77} as the compiler,
it does.
However, compiled by many other compilers,
values for pertinent portions of code,
it is important that compilers treat code so modified in the
same way so that the results of such programs are the same.
-@code{g77} helps in this regard by treating constants just
+@command{g77} helps in this regard by treating constants just
the same as variables in terms of determining their types
in a context-independent way.
Still, there is a lot of existing Fortran code that has
been written to depend on the way other compilers freely
interpret constants' types based on context, so anything
-@code{g77} can do to help flag cases of this in such code
+@command{g77} can do to help flag cases of this in such code
could be very helpful.
@node Equivalence Versus Equality
@cindex logical expressions, comparing
Use of @code{.EQ.} and @code{.NE.} on @code{LOGICAL} operands
-is not supported, except via @samp{-fugly-logint}, which is not
+is not supported, except via @option{-fugly-logint}, which is not
recommended except for legacy code (where the behavior expected
by the @emph{code} is assumed).
This requirement results in expression syntax with more certain
precedence (without requiring substantial context), making it easier
for programmers to read existing code.
-@code{g77} will avoid muddying up elements of the Fortran language
+@command{g77} will avoid muddying up elements of the Fortran language
that were well-designed in the first place.
(Ask C programmers about the precedence of expressions such as
@cindex side effects, order of evaluation
@cindex order of evaluation, side effects
-@code{g77} does not necessarily produce code that, when run, performs
+@command{g77} does not necessarily produce code that, when run, performs
side effects (such as those performed by function invocations)
in the same order as in some other compiler---or even in the same
order as another version, port, or invocation (using different
-command-line options) of @code{g77}.
+command-line options) of @command{g77}.
It is never safe to depend on the order of evaluation of side effects.
For example, an expression like this may very well behave differently
that your program really does what you intend; or the use of obsolete
features; or the use of nonstandard features of GNU Fortran.
Many warnings are issued only if you ask for them, with one of the
-@samp{-W} options (for instance, @samp{-Wall} requests a variety of
+@option{-W} options (for instance, @option{-Wall} requests a variety of
useful warnings).
@emph{Note:} Currently, the text of the line and a pointer to the column
-is printed in most @code{g77} diagnostics.
-Probably, as of version 0.6, @code{g77} will
+is printed in most @command{g77} diagnostics.
+Probably, as of version 0.6, @command{g77} will
no longer print the text of the source line, instead printing
the column number following the file name and line number in
a form that GNU Emacs recognizes.
This change is expected to speed up and reduce the memory usage
-of the @code{g77} compiler.
+of the @command{g77} compiler.
@c
@c Say this when it is true -- hopefully 0.6, maybe 0.7 or later. --burley
@c
@c (for instance) it fails to conform to a standard. In some cases,
@c however, the Fortran standard specifies that certain extensions are
@c forbidden, and a diagnostic @emph{must} be issued by a conforming
-@c compiler. The @samp{-pedantic} option tells GNU Fortran to issue warnings
-@c in such cases; @samp{-pedantic-errors} says to make them errors instead.
+@c compiler. The @option{-pedantic} option tells GNU Fortran to issue warnings
+@c in such cases; @option{-pedantic-errors} says to make them errors instead.
@c This does not mean that @emph{all} non-ANSI constructs get warnings
@c or errors.
for improvement of GNU Fortran are welcome in any case.
@end itemize
-Many, perhaps most, bug reports against @code{g77} turn out to
+Many, perhaps most, bug reports against @command{g77} turn out to
be bugs in the user's code.
While we find such bug reports educational, they sometimes take
a considerable amount of time to track down or at least respond
-to---time we could be spending making @code{g77}, not some user's
+to---time we could be spending making @command{g77}, not some user's
code, better.
Some steps you can take to verify that the bug is not certainly
-in the code you're compiling with @code{g77}:
+in the code you're compiling with @command{g77}:
@itemize @bullet
@item
-Compile your code using the @code{g77} options @samp{-W -Wall -O}.
-These options enable many useful warning; the @samp{-O} option
+Compile your code using the @command{g77} options @samp{-W -Wall -O}.
+These options enable many useful warning; the @option{-O} option
enables flow analysis that enables the uninitialized-variable
warning.
If you investigate the warnings and find evidence of possible bugs
-in your code, fix them first and retry @code{g77}.
+in your code, fix them first and retry @command{g77}.
@item
-Compile your code using the @code{g77} options @samp{-finit-local-zero},
-@samp{-fno-automatic}, @samp{-ffloat-store}, and various
+Compile your code using the @command{g77} options @option{-finit-local-zero},
+@option{-fno-automatic}, @option{-ffloat-store}, and various
combinations thereof.
If your code works with any of these combinations, that is not
-proof that the bug isn't in @code{g77}---a @code{g77} bug exposed
+proof that the bug isn't in @command{g77}---a @command{g77} bug exposed
by your code might simply be avoided, or have a different, more subtle
effect, when different options are used---but it can be a
strong indicator that your code is making unwarranted assumptions
being compiled and run on.
@xref{Overly Convenient Options,,Overly Convenient Command-Line Options},
-for information on the @samp{-fno-automatic} and
-@samp{-finit-local-zero} options and how to convert
+for information on the @option{-fno-automatic} and
+@option{-finit-local-zero} options and how to convert
their use into selective changes in your own code.
@item
@end smallexample
@item
-Try your code out using other Fortran compilers, such as @code{f2c}.
+Try your code out using other Fortran compilers, such as @command{f2c}.
If it does not work on at least one other compiler (assuming the
compiler supports the features the code needs), that is a strong
indicator of a bug in the code.
However, even if your code works on many compilers @emph{except}
-@code{g77}, that does @emph{not} mean the bug is in @code{g77}.
-It might mean the bug is in your code, and that @code{g77} simply
+@command{g77}, that does @emph{not} mean the bug is in @command{g77}.
+It might mean the bug is in your code, and that @command{g77} simply
exposes it more readily than other compilers.
@end itemize
@itemize @bullet
@item
The version of GNU Fortran.
-You can get this by running @code{g77} with the @samp{-v} option.
+You can get this by running @command{g77} with the @option{-v} option.
(Ignore any error messages that might be displayed
when the linker is run.)
by doing @samp{g77 -E @var{sourcefile} > @var{newfile}}.
Then, include the contents of @var{newfile} in the bug report.
(When you do this, use the same preprocessor options---such as
-@samp{-I}, @samp{-D}, and @samp{-U}---that you used in actual
+@option{-I}, @option{-D}, and @option{-U}---that you used in actual
compilation.)
A single statement is not enough of an example.
@item
The command arguments you gave GNU Fortran to compile that example
-and observe the bug. For example, did you use @samp{-O}? To guarantee
+and observe the bug. For example, did you use @option{-O}? To guarantee
you won't omit something important, list all the options.
If we were to try to guess the arguments, we would probably guess wrong
@item
If you send examples of assembler code output from GNU Fortran,
-please use @samp{-g} when you make them. The debugging information
+please use @option{-g} when you make them. The debugging information
includes source line numbers which are essential for correlating the
output with the input.
@cindex options, adding
@cindex adding options
-To add a new command-line option to @code{g77}, first decide
+To add a new command-line option to @command{g77}, first decide
what kind of option you wish to add.
-Search the @code{g77} and @code{gcc} documentation for one
+Search the @command{g77} and @command{gcc} documentation for one
or more options that is most closely like the one you want to add
(in terms of what kind of effect it has, and so on) to
help clarify its nature.
@item
@emph{Fortran options} are options that apply only
when compiling Fortran programs.
-They are accepted by @code{g77} and @code{gcc}, but
+They are accepted by @command{g77} and @command{gcc}, but
they apply only when compiling Fortran programs.
@item
@emph{Fortran options} are listed in the file
@file{@value{path-g77}/lang-options.h},
-which is used during the build of @code{gcc} to
+which is used during the build of @command{gcc} to
build a list of all options that are accepted by
at least one language's compiler.
This list goes into the @code{documented_lang_options} array
determine whether a particular option should be
offered to the linked-in front end for processing
by calling @code{lang_option_decode}, which, for
-@code{g77}, is in @file{@value{path-g77}/com.c} and just
+@command{g77}, is in @file{@value{path-g77}/com.c} and just
calls @code{ffe_decode_option}.
If the linked-in front end ``rejects'' a
This allows commands like @samp{gcc -fno-asm foo.c bar.f}
to work, even though Fortran compilation does
-not currently support the @samp{-fno-asm} option;
+not currently support the @option{-fno-asm} option;
even though the @code{f771} version of @code{lang_decode_option}
-rejects @samp{-fno-asm}, @file{toplev.c} doesn't
+rejects @option{-fno-asm}, @file{toplev.c} doesn't
produce a diagnostic because some other language (C)
does accept it.
This also means that commands like
@samp{g77 -fno-asm foo.f} yield no diagnostics,
despite the fact that no phase of the command was
-able to recognize and process @samp{-fno-asm}---perhaps
+able to recognize and process @option{-fno-asm}---perhaps
a warning about this would be helpful if it were
possible.
(especially when it comes to language constructs),
the practice of setting defaults in @file{target.h}
is likely to be deprecated and, ultimately, stopped
-in future versions of @code{g77}.
+in future versions of @command{g77}.
Accessor macros for Fortran options, used by code
-in the @code{g77} FFE, are defined in @file{@value{path-g77}/top.h}.
+in the @command{g77} FFE, are defined in @file{@value{path-g77}/top.h}.
@emph{Compiler options} are listed in @file{gcc/toplev.c}
in the array @code{f_options}.
You can set different defaults for @emph{Fortran-oriented}
or @emph{Fortran-reticent} compiler options by changing
-the source code of @code{g77} and rebuilding.
-How to do this depends on the version of @code{g77}:
+the source code of @command{g77} and rebuilding.
+How to do this depends on the version of @command{g77}:
@table @code
@item G77 0.5.24 (EGCS 1.1)
@itemx G77 0.5.25 (EGCS 1.2 - which became GCC 2.95)
Change the @code{lang_init_options} routine in @file{gcc/gcc/f/com.c}.
-(Note that these versions of @code{g77}
+(Note that these versions of @command{g77}
perform internal consistency checking automatically
-when the @samp{-fversion} option is specified.)
+when the @option{-fversion} option is specified.)
@item G77 0.5.23
@itemx G77 0.5.24 (EGCS 1.0)
-Change the way @code{f771} handles the @samp{-fset-g77-defaults}
+Change the way @code{f771} handles the @option{-fset-g77-defaults}
option, which is always provided as the first option when
-called by @code{g77} or @code{gcc}.
+called by @command{g77} or @command{gcc}.
This code is in @code{ffe_decode_options} in @file{@value{path-g77}/top.c}.
Have it change just the variables that you want to default
to a different setting for Fortran compiles compared to
compiles of other languages.
-The @samp{-fset-g77-defaults} option is passed to @code{f771}
+The @option{-fset-g77-defaults} option is passed to @code{f771}
automatically because of the specification information
kept in @file{@value{path-g77}/lang-specs.h}.
-This file tells the @code{gcc} command how to recognize,
+This file tells the @command{gcc} command how to recognize,
in this case, Fortran source files (those to be preprocessed,
and those that are not), and further, how to invoke the
appropriate programs (including @code{f771}) to process
those source files.
-It is in @file{@value{path-g77}/lang-specs.h} that @samp{-fset-g77-defaults},
-@samp{-fversion}, and other options are passed, as appropriate,
+It is in @file{@value{path-g77}/lang-specs.h} that @option{-fset-g77-defaults},
+@option{-fversion}, and other options are passed, as appropriate,
even when the user has not explicitly specified them.
-Other ``internal'' options such as @samp{-quiet} also
+Other ``internal'' options such as @option{-quiet} also
are passed via this mechanism.
@end table
@chapter Projects
@cindex projects
-If you want to contribute to @code{g77} by doing research,
+If you want to contribute to @command{g77} by doing research,
design, specification, documentation, coding, or testing,
the following information should give you some ideas.
More relevant information might be available from
@uref{ftp://alpha.gnu.org/gnu/g77/projects/}.
@menu
-* Efficiency:: Make @code{g77} itself compile code faster.
-* Better Optimization:: Teach @code{g77} to generate faster code.
-* Simplify Porting:: Make @code{g77} easier to configure, build,
+* Efficiency:: Make @command{g77} itself compile code faster.
+* Better Optimization:: Teach @command{g77} to generate faster code.
+* Simplify Porting:: Make @command{g77} easier to configure, build,
and install.
* More Extensions:: Features many users won't know to ask for.
-* Machine Model:: @code{g77} should better leverage @code{gcc}.
+* Machine Model:: @command{g77} should better leverage @command{gcc}.
* Internals Documentation:: Make maintenance easier.
* Internals Improvements:: Make internals more robust.
-* Better Diagnostics:: Make using @code{g77} on new code easier.
+* Better Diagnostics:: Make using @command{g77} on new code easier.
@end menu
@node Efficiency
unimplemented-statement catch-all.
@item
-Throughout @code{g77}, don't pass line/column pairs where
+Throughout @command{g77}, don't pass line/column pairs where
a simple @code{ffewhere} type, which points to the error as much as is
desired by the configuration, will do, and don't pass @code{ffelexToken} types
where a simple @code{ffewhere} type will do.
Handle @samp{DATA (A(I),I=1,1000000)/1000000*2/} more efficiently, especially
as regards the assembly output.
Some of this might require improving
-the back end, but lots of improvement in space/time required in @code{g77}
+the back end, but lots of improvement in space/time required in @command{g77}
itself can be fairly easily obtained without touching the back end.
Maybe type-conversion, where necessary, can be speeded up as well in
cases like the one shown (converting the @samp{2} into @samp{2.}).
@cindex optimization, better
@cindex code generation, improving
-Much of this work should be put off until after @code{g77} has
+Much of this work should be put off until after @command{g77} has
all the features necessary for its widespread acceptance as a
useful F77 compiler.
However, perhaps this work can be done in parallel during
@item
Do the equivalent of the trick of putting @samp{extern inline} in front
of every function definition in @code{libg2c} and #include'ing the resulting
-file in @code{f2c}+@code{gcc}---that is, inline all run-time-library functions
+file in @command{f2c}+@command{gcc}---that is, inline all run-time-library functions
that are at all worth inlining.
(Some of this has already been done, such as for integral exponentiation.)
Be a one-stop-shop-type
library, hence shareable and usable by all, in that what are now
library-build-time options in @code{libg2c} would be moved at least to the
-@code{g77} compile phase, if not to finer grains (such as choosing how
+@command{g77} compile phase, if not to finer grains (such as choosing how
list-directed I/O formatting is done by default at @code{OPEN} time, for
preconnected units via options or even statements in the main program
unit, maybe even on a per-I/O basis with appropriate pragma-like
@item
Probably requiring the new library design, change interface to
normally have @code{COMPLEX} functions return their values in the way
-@code{gcc} would if they were declared @code{__complex__ float},
+@command{gcc} would if they were declared @code{__complex__ float},
rather than using
the mechanism currently used by @code{CHARACTER} functions (whereby the
functions are compiled as returning void and their first arg is
a pointer to where to store the result).
(Don't append underscores to
-external names for @code{COMPLEX} functions in some cases once @code{g77} uses
-@code{gcc} rather than @code{f2c} calling conventions.)
+external names for @code{COMPLEX} functions in some cases once @command{g77} uses
+@command{gcc} rather than @command{f2c} calling conventions.)
@item
Do something useful with @code{doiter} references where possible.
@cindex porting, simplify
@cindex simplify porting
-Making @code{g77} easier to configure, port, build, and install, either
+Making @command{g77} easier to configure, port, build, and install, either
as a single-system compiler or as a cross-compiler, would be
very useful.
@item
A new library (replacing @code{libg2c}) should improve portability as well as
produce more optimal code.
-Further, @code{g77} and the new library should
+Further, @command{g77} and the new library should
conspire to simplify naming of externals, such as by removing unnecessarily
added underscores, and to reduce/eliminate the possibility of naming
conflicts, while making debugger more straightforward.
descriptors.
@item
-Possibly related to a new library, @code{g77} should produce the equivalent
-of a @code{gcc} @samp{main(argc, argv)} function when it compiles a
+Possibly related to a new library, @command{g77} should produce the equivalent
+of a @command{gcc} @samp{main(argc, argv)} function when it compiles a
main program unit, instead of compiling something that must be
called by a library
implementation of @code{main()}.
@item
The GBE needs to understand the difference between alignment
requirements and desires.
-For example, on Intel x86 machines, @code{g77} currently imposes
+For example, on Intel x86 machines, @command{g77} currently imposes
overly strict alignment requirements, due to the back end, but it
would be useful for Fortran and C programmers to be able to override
these @emph{recommendations} as long as they don't violate the actual
@cindex extensions, more
These extensions are not the sort of things users ask for ``by name'',
-but they might improve the usability of @code{g77}, and Fortran in
+but they might improve the usability of @command{g77}, and Fortran in
general, in the long run.
-Some of these items really pertain to improving @code{g77} internals
+Some of these items really pertain to improving @command{g77} internals
so that some popular extensions can be more easily supported.
@itemize @bullet
Make sure this is what users of this feature would expect.
@item
-Currently @code{g77} disallows @samp{READ(1'10)} since
+Currently @command{g77} disallows @samp{READ(1'10)} since
it is an obnoxious syntax, but
supporting it might be pretty easy if needed.
More details are needed, such
changes to @code{libg2c} or its replacement.
@item
-F90 and @code{g77} probably disagree about label scoping relative to
+F90 and @command{g77} probably disagree about label scoping relative to
@code{INTERFACE} and @code{END INTERFACE}, and their contained
procedure interface bodies (blocks?).
@node Machine Model
@section Machine Model
-This items pertain to generalizing @code{g77}'s view of
+This items pertain to generalizing @command{g77}'s view of
the machine model to more fully accept whatever the GBE
provides it via its configuration.
Switch to using @code{REAL_VALUE_TYPE} to represent floating-point constants
exclusively so the target float format need not be required.
This
-means changing the way @code{g77} handles initialization of aggregate areas
+means changing the way @command{g77} handles initialization of aggregate areas
having more than one type, such as @code{REAL} and @code{INTEGER},
because currently
it initializes them as if they were arrays of @code{char} and uses the
@item
Rely more and more on back-end info and capabilities, especially in the
-area of constants (where having the @code{g77} front-end's IL just store
+area of constants (where having the @command{g77} front-end's IL just store
the appropriate tree nodes containing constants might be best).
@item
Suite of C and Fortran programs that a user/administrator can run on a
-machine to help determine the configuration for @code{g77} before building
+machine to help determine the configuration for @command{g77} before building
and help determine if the compiler works (especially with whatever
libraries are installed) after building.
@end itemize
@node Internals Documentation
@section Internals Documentation
-Better info on how @code{g77} works and how to port it is needed.
+Better info on how @command{g77} works and how to port it is needed.
Much of this should be done only after the redesign planned for
0.6 is complete.
@xref{Front End}, which contains some information
-on @code{g77} internals.
+on @command{g77} internals.
@node Internals Improvements
@section Internals Improvements
-Some more items that would make @code{g77} more reliable
+Some more items that would make @command{g77} more reliable
and easier to maintain:
@itemize @bullet
of diagnostics.)
@item
-Come up with better naming conventions for @samp{-D} to establish requirements
+Come up with better naming conventions for @option{-D} to establish requirements
to achieve desired implementation dialect via @file{proj.h}.
@item
@item
Implement C macros @samp{RETURNS(value)} and @samp{SETS(something,value)}
in @file{proj.h}
-and use them throughout @code{g77} source code (especially in the definitions
+and use them throughout @command{g77} source code (especially in the definitions
of access macros in @samp{.h} files) so they can be tailored
to catch code writing into a @samp{RETURNS()} or reading from a @samp{SETS()}.
@chapter Diagnostics
@cindex diagnostics
-Some diagnostics produced by @code{g77} require sufficient explanation
+Some diagnostics produced by @command{g77} require sufficient explanation
that the explanations are given below, and the diagnostics themselves
identify the appropriate explanation.
foo.f:5: Invalid statement [info -f g77 M FOOEY]
@end smallexample
-More details about the above diagnostic is found in the @code{g77} Info
+More details about the above diagnostic is found in the @command{g77} Info
documentation, menu item @samp{M}, submenu item @samp{FOOEY},
which is displayed by typing the UNIX command
@samp{info -f g77 M FOOEY}.
@samp{FOOEY} is the menu item to select.
@iftex
-In this printed version of the @code{g77} manual, the above example
+In this printed version of the @command{g77} manual, the above example
points to a section, below, entitled @samp{FOOEY}---though, of course,
as the above is just a sample, no such section exists.
@end iftex
@itemize @bullet
@item
-Compile with the @code{g77} option @samp{-ff90}, to enable the
+Compile with the @command{g77} option @option{-ff90}, to enable the
Fortran 90 interpretation.
@item
-Compile with the @code{g77} options @samp{-fno-f90 -fugly-complex},
+Compile with the @command{g77} options @samp{-fno-f90 -fugly-complex},
to enable the non-Fortran-90 interpretations.
@end itemize
This diagnostic is designed to catch cases where a program
might depend on using the name @var{intrinsic} as an intrinsic
in one program unit and as a global name (such as the name
-of a subroutine or function) in another, but @code{g77} recognizes
+of a subroutine or function) in another, but @command{g77} recognizes
the name as an intrinsic in both cases.
After verifying that the program unit making implicit use
program unit to prevent this warning.
This and related warnings are disabled by using
-the @samp{-Wno-globals} option when compiling.
+the @option{-Wno-globals} option when compiling.
Note that this warning is not issued for standard intrinsics.
Standard intrinsics include those described in the FORTRAN 77
-standard and, if @samp{-ff90} is specified, those described
+standard and, if @option{-ff90} is specified, those described
in the Fortran 90 standard.
Such intrinsics are not as likely to be confused with user
procedures as intrinsics provided as extensions to the
-standard by @code{g77}.
+standard by @command{g77}.
@node INTGLOB
@section @code{INTGLOB}
used as an intrinsic in another program unit.
This diagnostic is designed to catch cases where a program
-intends to use a name entirely as a global name, but @code{g77}
+intends to use a name entirely as a global name, but @command{g77}
recognizes the name as an intrinsic in the program unit that
references the name, a situation that would likely produce
incorrect code.
The above example defines a program unit named @samp{TIME}, but
the reference to @samp{TIME} in the main program unit @samp{SAMP}
-is normally treated by @code{g77} as a reference to the intrinsic
+is normally treated by @command{g77} as a reference to the intrinsic
@code{TIME()} (unless a command-line option that prevents such
treatment has been specified).
As a result, the program @samp{SAMP} will @emph{not}
invoke the @samp{TIME} function in the same source file.
-Since @code{g77} recognizes @code{libU77} procedures as
+Since @command{g77} recognizes @code{libU77} procedures as
intrinsics, and since some existing code uses the same names
for its own procedures as used by some @code{libU77}
procedures, this situation is expected to arise often enough
Or, if you believe the program unit is designed to invoke the
program-defined procedure instead of the intrinsic (as
-recognized by @code{g77}), add an @samp{EXTERNAL @var{intrinsic}}
+recognized by @command{g77}), add an @samp{EXTERNAL @var{intrinsic}}
statement to the program unit that references the name to
prevent this warning.
This and related warnings are disabled by using
-the @samp{-Wno-globals} option when compiling.
+the @option{-Wno-globals} option when compiling.
Note that this warning is not issued for standard intrinsics.
Standard intrinsics include those described in the FORTRAN 77
-standard and, if @samp{-ff90} is specified, those described
+standard and, if @option{-ff90} is specified, those described
in the Fortran 90 standard.
Such intrinsics are not as likely to be confused with user
procedures as intrinsics provided as extensions to the
-standard by @code{g77}.
+standard by @command{g77}.
@node LEX
@section @code{LEX}
contains lots of bugs, it might be C++ source code.
@item
-The source file contains free-form Fortran code, but @samp{-ffree-form}
+The source file contains free-form Fortran code, but @option{-ffree-form}
was not specified on the command line to compile it.
Free form is a newer form for Fortran code.
If the file's suffix is @samp{.f}, @samp{.for}, or @samp{.FOR},
the file normally will be compiled @emph{without} preprocessing
-by @code{g77}.
+by @command{g77}.
Change the file's suffix from @samp{.f} to @samp{.F}
(or, on systems with case-insensitive file names,
to @samp{.fpp} or @samp{.FPP}),
from @samp{.for} to @samp{.fpp},
or from @samp{.FOR} to @samp{.FPP}.
-@code{g77} compiles files with such names @emph{with}
+@command{g77} compiles files with such names @emph{with}
preprocessing.
@pindex cpp
@cindex preprocessor
@cindex cpp program
@cindex programs, cpp
-@cindex @samp{-x f77-cpp-input} option
-@cindex options, @samp{-x f77-cpp-input}
-Or, learn how to use @code{gcc}'s @samp{-x} option to specify
+@cindex @option{-x f77-cpp-input} option
+@cindex options, @option{-x f77-cpp-input}
+Or, learn how to use @command{gcc}'s @option{-x} option to specify
the language @samp{f77-cpp-input} for Fortran files that
require preprocessing.
@xref{Overall Options,,gcc,Using and Porting GNU CC}.
@cindex in-line code
@cindex compilation, in-line
This distinction, between warnings and errors,
-is due primarily to the present tendency of the @code{gcc} back end
+is due primarily to the present tendency of the @command{gcc} back end
to inline only those procedure invocations that are
@emph{preceded} by the corresponding procedure definitions.
-If the @code{gcc} back end is changed
+If the @command{gcc} back end is changed
to inline ``forward references'',
in which invocations precede definitions,
-the @code{g77} front end will be changed
+the @command{g77} front end will be changed
to treat both orderings as errors, accordingly.
-The sorts of disagreements that are diagnosed by @code{g77} include
+The sorts of disagreements that are diagnosed by @command{g77} include
whether a procedure is a subroutine or function;
if it is a function, the type of the return value of the procedure;
the number of arguments the procedure accepts;
However, if that is not immediately practical,
and the code has been working for some time,
it is possible it will work
-when compiled with the @samp{-fno-globals} option.
+when compiled with the @option{-fno-globals} option.
-The @samp{-fno-globals} option
+The @option{-fno-globals} option
causes these diagnostics to all be warnings
and disables all inlining of references to global procedures
(to avoid subsequent compiler crashes and bad-code generation).
-Use of the @samp{-Wno-globals} option as well as @samp{-fno-globals}
+Use of the @option{-Wno-globals} option as well as @option{-fno-globals}
suppresses all of these diagnostics.
-(@samp{-Wno-globals} by itself disables only the warnings,
+(@option{-Wno-globals} by itself disables only the warnings,
not the errors.)
-After using @samp{-fno-globals} to work around these problems,
+After using @option{-fno-globals} to work around these problems,
it is wise to stop using that option and address them by fixing
the Fortran code, because such problems, while they might not
actually result in bugs on some systems, indicate that the code
@section @code{LINKFAIL}
@noindent
-On AIX 4.1, @code{g77} might not build with the native (non-GNU) tools
-due to a linker bug in coping with the @samp{-bbigtoc} option which
+On AIX 4.1, @command{g77} might not build with the native (non-GNU) tools
+due to a linker bug in coping with the @option{-bbigtoc} option which
leads to a @samp{Relocation overflow} error. The GNU linker is not
recommended on current AIX versions, though; it was developed under a
now-unsupported version. This bug is said to be fixed by `update PTF
U455193 for APAR IX75823'.
-Compiling with @samp{-mminimal-toc}
+Compiling with @option{-mminimal-toc}
might solve this problem, e.g.@: by adding
@smallexample
BOOT_CFLAGS='-mminimal-toc -O2 -g'
@setfilename g77
@settitle GNU project Fortran 77 compiler.
@c man begin SYNOPSIS
-g77 [@option{-c}|@option{-S}|@option{-E}] [@option{-std=}@var{standard}]
+g77 [@option{-c}|@option{-S}|@option{-E}]
[@option{-g}] [@option{-pg}] [@option{-O}@var{level}]
[@option{-W}@var{warn}@dots{}] [@option{-pedantic}]
[@option{-I}@var{dir}@dots{}] [@option{-L}@var{dir}@dots{}]
@c man end
@c man begin AUTHOR
See the Info entry for @file{g77}, or
-@w{@uref{http://gcc.gnu.org/thanks.html}}, for contributors to G77@.
+@w{@uref{http://gcc.gnu.org/thanks.html}}, for contributors to GCC and G77@.
@c man end
@end ignore
@c man begin DESCRIPTION
-The @code{g77} command supports all the options supported by the
-@code{gcc} command.
+The @command{g77} command supports all the options supported by the
+@command{gcc} command.
@xref{Invoking GCC,,GNU CC Command Options,gcc,Using and Porting GNU CC},
for information
-on the non-Fortran-specific aspects of the @code{gcc} command (and,
-therefore, the @code{g77} command).
+on the non-Fortran-specific aspects of the @command{gcc} command (and,
+therefore, the @command{g77} command).
@cindex options, negative forms
@cindex negative forms of options
-All @code{gcc} and @code{g77} options
-are accepted both by @code{g77} and by @code{gcc}
+All @command{gcc} and @command{g77} options
+are accepted both by @command{g77} and by @command{gcc}
(as well as any other drivers built at the same time,
such as @code{g++}),
-since adding @code{g77} to the @code{gcc} distribution
-enables acceptance of @code{g77}-specific options
+since adding @command{g77} to the @command{gcc} distribution
+enables acceptance of @command{g77} options
by all of the relevant drivers.
In some cases, options have positive and negative forms;
-the negative form of @samp{-ffoo} would be @samp{-fno-foo}.
+the negative form of @option{-ffoo} would be @option{-fno-foo}.
This manual documents only one of these two forms, whichever
one is not the default.
@c man end
@menu
-* Option Summary:: Brief list of all @code{g77} options,
+* Option Summary:: Brief list of all @command{g77} options,
without explanations.
* Overall Options:: Controlling the kind of output:
an executable, object files, assembler files,
@table @emph
@item Overall Options
@xref{Overall Options,,Options Controlling the Kind of Output}.
-@smallexample
--fversion -fset-g77-defaults -fno-silent
-@end smallexample
+@gccoptlist{
+-fversion -fset-g77-defaults -fno-silent}
@item Shorthand Options
@xref{Shorthand Options}.
-@smallexample
--ff66 -fno-f66 -ff77 -fno-f77 -fno-ugly
-@end smallexample
+@gccoptlist{
+-ff66 -fno-f66 -ff77 -fno-f77 -fno-ugly}
@item Fortran Language Options
@xref{Fortran Dialect Options,,Options Controlling Fortran Dialect}.
-@smallexample
+@gccoptlist{
-ffree-form -fno-fixed-form -ff90
-fvxt -fdollar-ok -fno-backslash
-fno-ugly-args -fno-ugly-assign -fno-ugly-assumed
-funix-intrinsics-disable -funix-intrinsics-enable
-fvxt-intrinsics-delete -fvxt-intrinsics-hide
-fvxt-intrinsics-disable -fvxt-intrinsics-enable
--ffixed-line-length-@var{n} -ffixed-line-length-none
-@end smallexample
+-ffixed-line-length-@var{n} -ffixed-line-length-none}
@item Warning Options
@xref{Warning Options,,Options to Request or Suppress Warnings}.
-@smallexample
+@gccoptlist{
-fsyntax-only -pedantic -pedantic-errors -fpedantic
-w -Wno-globals -Wimplicit -Wunused -Wuninitialized
-Wall -Wsurprising
--Werror -W
-@end smallexample
+-Werror -W}
@item Debugging Options
@xref{Debugging Options,,Options for Debugging Your Program or GCC}.
-@smallexample
--g
-@end smallexample
+@gccoptlist{
+-g}
@item Optimization Options
@xref{Optimize Options,,Options that Control Optimization}.
-@smallexample
+@gccoptlist{
-malign-double
-ffloat-store -fforce-mem -fforce-addr -fno-inline
-ffast-math -fstrength-reduce -frerun-cse-after-loop
-fschedule-insns -fschedule-insn2 -fcaller-saves
-funroll-loops -funroll-all-loops
-fno-move-all-movables -fno-reduce-all-givs
--fno-rerun-loop-opt
-@end smallexample
+-fno-rerun-loop-opt}
@item Directory Options
@xref{Directory Options,,Options for Directory Search}.
-@smallexample
--I@var{dir} -I-
-@end smallexample
+@gccoptlist{
+-I@var{dir} -I-}
@item Code Generation Options
@xref{Code Gen Options,,Options for Code Generation Conventions}.
-@smallexample
+@gccoptlist{
-fno-automatic -finit-local-zero -fno-f2c
-ff2c-library -fno-underscoring -fno-ident
-fpcc-struct-return -freg-struct-return
-falias-check -fargument-alias
-fargument-noalias -fno-argument-noalias-global
-fno-globals -fflatten-arrays
--fbounds-check -ffortran-bounds-check
-@end smallexample
+-fbounds-check -ffortran-bounds-check}
@end table
@c man end
@xref{Overall Options,,gcc,Using and Porting GNU CC}, for
information on suffixes recognized by GNU CC.
-@table @code
+@table @gcctabopt
@cindex .f filename suffix
@cindex .for filename suffix
@cindex .FOR filename suffix
as @code{#include}, @code{#define}, @code{#if}, and so on.
You can force @samp{.f} files to be preprocessed by @code{cpp} by using
-@samp{-x f77-cpp-input}.
+@option{-x f77-cpp-input}.
@xref{LEX}.
@cindex preprocessor
Ratfor source code, which must be preprocessed by the @code{ratfor}
command, which is available separately (as it is not yet part of the GNU
Fortran distribution).
-One version in Fortran, adapted for use with @code{g77}, is at
+One version in Fortran, adapted for use with @command{g77} is at
@uref{ftp://members.aol.com/n8tm/rat7.uue} (of uncertain copyright
status). Another, public domain version in C is at
@uref{http://sepwww.stanford.edu/sep/prof/ratfor.shar.2}.
line being effectively commented out---unfortunate if that
line is a non-comment line of important code!
-@emph{Note:} The @samp{-traditional} and @samp{-undef} flags are supplied
+@emph{Note:} The @option{-traditional} and @option{-undef} flags are supplied
to @code{cpp} by default, to help avoid unpleasant surprises.
@xref{Preprocessor Options,,Options Controlling the Preprocessor,
gcc,Using and Porting GNU CC}.
substitution by C predefines.
Thus, if you want to do system-specific
tests, use, for example, @samp{#ifdef __linux__} rather than @samp{#ifdef linux}.
-Use the @samp{-v} option to see exactly how the preprocessor is invoked.
+Use the @option{-v} option to see exactly how the preprocessor is invoked.
@cindex /*
-Unfortunately, the @samp{-traditional} flag will not avoid an error from
+Unfortunately, the @option{-traditional} flag will not avoid an error from
anything that @code{cpp} sees as an unterminated C comment, such as:
@smallexample
C Some Fortran compilers accept /* as starting
@xref{Trailing Comment}.
The following options that affect overall processing are recognized
-by the @code{g77} and @code{gcc} commands in a GNU Fortran installation:
+by the @command{g77} and @command{gcc} commands in a GNU Fortran installation:
-@table @code
+@table @gcctabopt
@cindex -fversion option
@cindex options, -fversion
@cindex printing version information
@cindex internal consistency checks
@cindex checks, of internal consistency
@item -fversion
-Ensure that the @code{g77}-specific version of the compiler phase is reported,
+Ensure that the @command{g77} version of the compiler phase is reported,
if run,
and, starting in @code{egcs} version 1.1,
that internal consistency checks in the @file{f771} program are run.
-This option is supplied automatically when @samp{-v} or @samp{--verbose}
-is specified as a command-line option for @code{g77} or @code{gcc}
+This option is supplied automatically when @option{-v} or @option{--verbose}
+is specified as a command-line option for @command{g77} or @command{gcc}
and when the resulting commands compile Fortran source files.
+In GCC 3.1, this is changed back to the behaviour @command{gcc} displays
+for @samp{.c} files.
+
@cindex -fset-g77-defaults option
@cindex options, -fset-g77-defaults
@item -fset-g77-defaults
@cindex consistency checks
@cindex internal consistency checks
@cindex checks, of internal consistency
-Set up whatever @code{gcc} options are to apply to Fortran
+Set up whatever @command{gcc} options are to apply to Fortran
compilations, and avoid running internal consistency checks
that might take some time.
This option is supplied automatically when compiling Fortran code
-via the @code{g77} or @code{gcc} command.
+via the @command{g77} or @command{gcc} command.
The description of this option is provided so that users seeing
it in the output of, say, @samp{g77 -v} understand why it is
there.
@cindex code, modifying
Also, developers who run @code{f771} directly might want to specify it
by hand to get the same defaults as they would running @code{f771}
-via @code{g77} or @code{gcc}.
+via @command{g77} or @command{gcc}
However, such developers should, after linking a new @code{f771}
executable, invoke it without this option once,
e.g. via @kbd{./f771 -quiet < /dev/null},
to ensure that they have not introduced any
internal inconsistencies (such as in the table of
-intrinsics) before proceeding---@code{g77} will crash
+intrinsics) before proceeding---@command{g77} will crash
with a diagnostic if it detects an inconsistency.
@cindex -fno-silent option
@item -fno-silent
Print (to @code{stderr}) the names of the program units as
they are compiled, in a form similar to that used by popular
-UNIX @code{f77} implementations and @code{f2c}.
+UNIX @code{f77} implementations and @command{f2c}
@end table
@xref{Overall Options,,Options Controlling the Kind of Output,
gcc,Using and Porting GNU CC}, for information
-on more options that control the overall operation of the @code{gcc} command
-(and, by extension, the @code{g77} command).
+on more options that control the overall operation of the @command{gcc} command
+(and, by extension, the @command{g77} command).
@node Shorthand Options
@section Shorthand Options
The following options serve as ``shorthand''
for other options accepted by the compiler:
-@table @code
+@table @gcctabopt
@cindex -fugly option
@cindex options, -fugly
@item -fugly
Specify that the program is written in idiomatic FORTRAN 66.
Same as @samp{-fonetrip -fugly-assumed}.
-The @samp{-fno-f66} option is the inverse of @samp{-ff66}.
+The @option{-fno-f66} option is the inverse of @option{-ff66}.
As such, it is the same as @samp{-fno-onetrip -fno-ugly-assumed}.
The meaning of this option is likely to be refined as future
-versions of @code{g77} provide more compatibility with other
+versions of @command{g77} provide more compatibility with other
existing and obsolete Fortran implementations.
@cindex -ff77 option
@cindex f77 compatibility
@cindex compatibility, f77
Specify that the program is written in idiomatic UNIX FORTRAN 77
-and/or the dialect accepted by the @code{f2c} product.
+and/or the dialect accepted by the @command{f2c} product.
Same as @samp{-fbackslash -fno-typeless-boz}.
The meaning of this option is likely to be refined as future
-versions of @code{g77} provide more compatibility with other
+versions of @command{g77} provide more compatibility with other
existing and obsolete Fortran implementations.
@cindex -fno-f77 option
@cindex options, -fno-f77
@item -fno-f77
@cindex UNIX f77
-The @samp{-fno-f77} option is @emph{not} the inverse
-of @samp{-ff77}.
+The @option{-fno-f77} option is @emph{not} the inverse
+of @option{-ff77}.
It specifies that the program is not written in idiomatic UNIX
-FORTRAN 77 or @code{f2c}, but in a more widely portable dialect.
-@samp{-fno-f77} is the same as @samp{-fno-backslash}.
+FORTRAN 77 or @command{f2c} but in a more widely portable dialect.
+@option{-fno-f77} is the same as @option{-fno-backslash}.
The meaning of this option is likely to be refined as future
-versions of @code{g77} provide more compatibility with other
+versions of @command{g77} provide more compatibility with other
existing and obsolete Fortran implementations.
@end table
The following options control the dialect of Fortran
that the compiler accepts:
-@table @code
+@table @gcctabopt
@cindex -ffree-form option
@cindex options, -ffree-form
@cindex -fno-fixed-form option
Fortran 90 constructs are recognized.
(Other Fortran 90 constructs
might or might not be recognized depending on other options such as
-@samp{-fvxt}, @samp{-ff90-intrinsics-enable}, and the
+@option{-fvxt}, @option{-ff90-intrinsics-enable}, and the
current level of support for Fortran 90.)
@xref{Fortran 90}, for more information.
GNU Fortran (based on FORTRAN 77 and akin to Fortran 90)
or VXT Fortran (more like VAX FORTRAN).
-The default is @samp{-fno-vxt}.
-@samp{-fvxt} specifies that the VXT Fortran interpretations
+The default is @option{-fno-vxt}.
+@option{-fvxt} specifies that the VXT Fortran interpretations
for those constructs are to be chosen.
@xref{VXT Fortran}, for more information.
Specify that @samp{\} is not to be specially interpreted in character
and Hollerith constants a la C and many UNIX Fortran compilers.
-For example, with @samp{-fbackslash} in effect, @samp{A\nB} specifies
+For example, with @option{-fbackslash} in effect, @samp{A\nB} specifies
three characters, with the second one being newline.
-With @samp{-fno-backslash}, it specifies four characters,
+With @option{-fno-backslash}, it specifies four characters,
@samp{A}, @samp{\}, @samp{n}, and @samp{B}.
-Note that @code{g77} implements a fairly general form of backslash
+Note that @command{g77} implements a fairly general form of backslash
processing that is incompatible with the narrower forms supported
by some other compilers.
-For example, @samp{'A\003B'} is a three-character string in @code{g77},
+For example, @samp{'A\003B'} is a three-character string in @command{g77}
whereas other compilers that support backslash might not support
the three-octal-digit form, and thus treat that string as longer
than three characters.
@xref{Backslash in Constants}, for
-information on why @samp{-fbackslash} is the default
-instead of @samp{-fno-backslash}.
+information on why @option{-fbackslash} is the default
+instead of @option{-fno-backslash}.
@cindex -fno-ugly-args option
@cindex options, -fno-ugly-args
For example, @samp{CALL FOO(,)} is treated as
@samp{CALL FOO(%VAL(0), %VAL(0))}.
That is, @emph{two} null arguments are specified
-by the procedure call when @samp{-fugly-comma} is in force.
+by the procedure call when @option{-fugly-comma} is in force.
And @samp{F = FUNC()} is treated as @samp{F = FUNC(%VAL(0))}.
-The default behavior, @samp{-fno-ugly-comma}, is to ignore
+The default behavior, @option{-fno-ugly-comma}, is to ignore
a single trailing comma in an argument list.
So, by default, @samp{CALL FOO(X,)} is treated
exactly the same as @samp{CALL FOO(X)}.
this is used to permit @code{COMPLEX(KIND=2)}
(@code{DOUBLE COMPLEX}) operands.
-The @samp{-ff90} option controls the interpretation
+The @option{-ff90} option controls the interpretation
of this construct.
@xref{Ugly Complex Part Extraction}, for more information.
initialize numeric types and vice versa.
For example, @samp{DATA I/'F'/, CHRVAR/65/, J/4HABCD/} is disallowed by
-@samp{-fno-ugly-init}.
+@option{-fno-ugly-init}.
@xref{Ugly Conversion of Initializers}, for more information.
expects this behavior from its @code{DO} loops, although that
standard did not specify this behavior.
-The @samp{-fonetrip} option specifies that the source file(s) being
+The @option{-fonetrip} option specifies that the source file(s) being
compiled require one-trip loops.
This option affects only those loops specified by the (iterative) @code{DO}
@cindex options, -fintrin-case-any
@item -fintrin-case-any
Specify expected case for intrinsic names.
-@samp{-fintrin-case-lower} is the default.
+@option{-fintrin-case-lower} is the default.
@cindex -fmatch-case-initcap option
@cindex options, -fmatch-case-initcap
@cindex options, -fmatch-case-any
@item -fmatch-case-any
Specify expected case for keywords.
-@samp{-fmatch-case-lower} is the default.
+@option{-fmatch-case-lower} is the default.
@cindex -fsource-case-upper option
@cindex options, -fsource-case-upper
@item -fsource-case-preserve
Specify whether source text other than character and Hollerith constants
is to be translated to uppercase, to lowercase, or preserved as is.
-@samp{-fsource-case-lower} is the default.
+@option{-fsource-case-lower} is the default.
@cindex -fsymbol-case-initcap option
@cindex options, -fsymbol-case-initcap
@cindex options, -fsymbol-case-any
@item -fsymbol-case-any
Specify valid cases for user-defined symbol names.
-@samp{-fsymbol-case-any} is the default.
+@option{-fsymbol-case-any} is the default.
@cindex -fcase-strict-upper option
@cindex options, -fcase-strict-upper
@cindex @code{badu77} intrinsics
@cindex intrinsics, @code{badu77}
Specify status of UNIX intrinsics having inappropriate forms.
-@samp{-fbadu77-intrinsics-enable} is the default.
+@option{-fbadu77-intrinsics-enable} is the default.
@xref{Intrinsic Groups}.
@cindex -ff2c-intrinsics-delete option
@cindex -ff2c-intrinsics-enable option
@cindex options, -ff2c-intrinsics-enable
@item -ff2c-intrinsics-enable
-@cindex @code{f2c} intrinsics
-@cindex intrinsics, @code{f2c}
+@cindex @command{f2c} intrinsics
+@cindex intrinsics, @command{f2c}
Specify status of f2c-specific intrinsics.
-@samp{-ff2c-intrinsics-enable} is the default.
+@option{-ff2c-intrinsics-enable} is the default.
@xref{Intrinsic Groups}.
@cindex -ff90-intrinsics-delete option
@cindex Fortran 90, intrinsics
@cindex intrinsics, Fortran 90
Specify status of F90-specific intrinsics.
-@samp{-ff90-intrinsics-enable} is the default.
+@option{-ff90-intrinsics-enable} is the default.
@xref{Intrinsic Groups}.
@cindex -fgnu-intrinsics-delete option
@cindex @code{COMPLEX} intrinsics
@cindex intrinsics, @code{COMPLEX}
Specify status of Digital's COMPLEX-related intrinsics.
-@samp{-fgnu-intrinsics-enable} is the default.
+@option{-fgnu-intrinsics-enable} is the default.
@xref{Intrinsic Groups}.
@cindex -fmil-intrinsics-delete option
@cindex MIL-STD 1753
@cindex intrinsics, MIL-STD 1753
Specify status of MIL-STD-1753-specific intrinsics.
-@samp{-fmil-intrinsics-enable} is the default.
+@option{-fmil-intrinsics-enable} is the default.
@xref{Intrinsic Groups}.
@cindex -funix-intrinsics-delete option
@cindex UNIX intrinsics
@cindex intrinsics, UNIX
Specify status of UNIX intrinsics.
-@samp{-funix-intrinsics-enable} is the default.
+@option{-funix-intrinsics-enable} is the default.
@xref{Intrinsic Groups}.
@cindex -fvxt-intrinsics-delete option
@cindex VXT intrinsics
@cindex intrinsics, VXT
Specify status of VXT intrinsics.
-@samp{-fvxt-intrinsics-enable} is the default.
+@option{-fvxt-intrinsics-enable} is the default.
@xref{Intrinsic Groups}.
@cindex -ffixed-line-length-@var{n} option
@var{n} may be @samp{none}, meaning that the entire line is meaningful
and that continued character constants never have implicit spaces appended
to them to fill out the line.
-@samp{-ffixed-line-length-0} means the same thing as
-@samp{-ffixed-line-length-none}.
+@option{-ffixed-line-length-0} means the same thing as
+@option{-ffixed-line-length-none}.
@xref{Source Form}, for more information.
@end table
are not inherently erroneous but which are risky or suggest there
might have been an error.
-You can request many specific warnings with options beginning @samp{-W},
-for example @samp{-Wimplicit} to request warnings on implicit
+You can request many specific warnings with options beginning @option{-W},
+for example @option{-Wimplicit} to request warnings on implicit
declarations. Each of these specific warning options also has a
-negative form beginning @samp{-Wno-} to turn off warnings;
-for example, @samp{-Wno-implicit}. This manual lists only one of the
+negative form beginning @option{-Wno-} to turn off warnings;
+for example, @option{-Wno-implicit}. This manual lists only one of the
two forms, whichever is not the default.
These options control the amount and kinds of warnings produced by GNU
Fortran:
-@table @code
+@table @gcctabopt
@cindex syntax checking
@cindex -fsyntax-only option
@cindex options, -fsyntax-only
@cindex options, -pedantic
@item -pedantic
Issue warnings for uses of extensions to ANSI FORTRAN 77.
-@samp{-pedantic} also applies to C-language constructs where they
+@option{-pedantic} also applies to C-language constructs where they
occur in GNU Fortran source files, such as use of @samp{\e} in a
character constant within a directive like @samp{#include}.
Fortran features are supported as well.
With this option, many of them are rejected.
-Some users try to use @samp{-pedantic} to check programs for strict ANSI
+Some users try to use @option{-pedantic} to check programs for strict ANSI
conformance.
They soon find that it does not do quite what they want---it finds some
non-ANSI practices, but not all.
-However, improvements to @code{g77} in this area are welcome.
+However, improvements to @command{g77} in this area are welcome.
@cindex -pedantic-errors option
@cindex options, -pedantic-errors
@item -pedantic-errors
-Like @samp{-pedantic}, except that errors are produced rather than
+Like @option{-pedantic}, except that errors are produced rather than
warnings.
@cindex -fpedantic option
@cindex options, -fpedantic
@item -fpedantic
-Like @samp{-pedantic}, but applies only to Fortran constructs.
+Like @option{-pedantic}, but applies only to Fortran constructs.
@cindex -w option
@cindex options, -w
Has an effect similar to using the @code{IMPLICIT NONE} statement
in every program unit.
(Some Fortran compilers provide this feature by an option
-named @samp{-u} or @samp{/WARNINGS=DECLARATIONS}.)
+named @option{-u} or @samp{/WARNINGS=DECLARATIONS}.)
@cindex -Wunused option
@cindex options, -Wunused
These warnings are possible only in optimizing compilation,
because they require data-flow information that is computed only
-when optimizing. If you don't specify @samp{-O}, you simply won't
+when optimizing. If you don't specify @option{-O}, you simply won't
get these warnings.
These warnings occur only for variables that are candidates for
@item -Wall
@cindex all warnings
@cindex warnings, all
-The @samp{-Wunused} and @samp{-Wuninitialized} options combined.
+The @option{-Wunused} and @option{-Wuninitialized} options combined.
These are all the
options which pertain to usage that we recommend avoiding and that we
believe is easy to avoid.
-(As more warnings are added to @code{g77}, some might
-be added to the list enabled by @samp{-Wall}.)
+(As more warnings are added to @command{g77} some might
+be added to the list enabled by @option{-Wall}.)
@end table
-The remaining @samp{-W@dots{}} options are not implied by @samp{-Wall}
+The remaining @option{-W@dots{}} options are not implied by @option{-Wall}
because they warn about constructions that we consider reasonable to
use, on occasion, in clean programs.
-@table @code
+@table @gcctabopt
@c @item -W
@c Print extra warning messages for these events:
@c
@c @itemize @bullet
@c @item
-@c If @samp{-Wall} or @samp{-Wunused} is also specified, warn about unused
+@c If @option{-Wall} or @option{-Wunused} is also specified, warn about unused
@c arguments.
@c
@c @end itemize
Such a construct is nonstandard, and can produce
unexpected results in more complicated situations such
as @samp{X**-Y*Z}.
-@code{g77}, along with many other compilers, interprets
+@command{g77} along with many other compilers, interprets
this example differently than many programmers, and a few
other compilers.
-Specifically, @code{g77} interprets @samp{X**-Y*Z} as
+Specifically, @command{g77} interprets @samp{X**-Y*Z} as
@samp{(X**(-Y))*Z}, while others might think it should
be interpreted as @samp{X**(-(Y*Z))}.
A revealing example is the constant expression @samp{2**-2*1.},
-which @code{g77} evaluates to .25, while others might evaluate
+which @command{g77} evaluates to .25, while others might evaluate
it to 0., the difference resulting from the way precedence affects
type promotion.
-(The @samp{-fpedantic} option also warns about expressions
+(The @option{-fpedantic} option also warns about expressions
having two arithmetic operators in a row.)
@item
of integral type---that is, using @code{REAL}
variables as loop control variables.
Although such loops can be written to work in the
-``obvious'' way, the way @code{g77} is required by the
+``obvious'' way, the way @command{g77} is required by the
Fortran standard to interpret such code is likely to
be quite different from the way many programmers expect.
(This is true of all @code{DO} loops, but the differences
@cindex extra warnings
@cindex warnings, extra
Turns on ``extra warnings'' and, if optimization is specified
-via @samp{-O}, the @samp{-Wuninitialized} option.
-(This might change in future versions of @code{g77}.)
+via @option{-O}, the @option{-Wuninitialized} option.
+(This might change in future versions of @command{g77}
``Extra warnings'' are issued for:
@cindex arguments, unused
@cindex unused dummies
@cindex dummies, unused
-Unused parameters to a procedure (when @samp{-Wunused} also is
+Unused parameters to a procedure (when @option{-Wunused} also is
specified).
@item
@xref{Warning Options,,Options to Request or Suppress Warnings,
gcc,Using and Porting GNU CC}, for information on more options offered
-by the GBE shared by @code{g77}, @code{gcc}, and other GNU compilers.
+by the GBE shared by @command{g77} @command{gcc} and other GNU compilers.
Some of these have no effect when compiling programs written in Fortran:
-@table @code
+@table @gcctabopt
@cindex -Wcomment option
@cindex options, -Wcomment
@item -Wcomment
@cindex debugging information options
GNU Fortran has various special options that are used for debugging
-either your program or @code{g77}.
+either your program or @command{g77}
-@table @code
+@table @gcctabopt
@cindex -g option
@cindex options, -g
@item -g
@cindex options, optimization
Most Fortran users will want to use no optimization when
-developing and testing programs, and use @samp{-O} or @samp{-O2} when
+developing and testing programs, and use @option{-O} or @option{-O2} when
compiling programs for late-cycle testing and for production use.
However, note that certain diagnostics---such as for uninitialized
-variables---depend on the flow analysis done by @samp{-O}, i.e.@: you
-must use @samp{-O} or @samp{-O2} to get such diagnostics.
+variables---depend on the flow analysis done by @option{-O}, i.e.@: you
+must use @option{-O} or @option{-O2} to get such diagnostics.
The following flags have particular applicability when
compiling Fortran programs:
-@table @code
+@table @gcctabopt
@cindex -malign-double option
@cindex options, -malign-double
@item -malign-double
(Intel x86 architecture only.)
-Noticeably improves performance of @code{g77} programs making
+Noticeably improves performance of @command{g77} programs making
heavy use of @code{REAL(KIND=2)} (@code{DOUBLE PRECISION}) data
on some systems.
In particular, systems using Pentium, Pentium Pro, 586, and
across various system configurations, versions of the program,
and data sets.
-@emph{Note:} The warning in the @code{gcc} documentation about
+@emph{Note:} The warning in the @command{gcc} documentation about
this option does not apply, generally speaking, to Fortran
-code compiled by @code{g77}.
+code compiled by @command{g77}
@xref{Aligned Data}, for more information on alignment issues.
-@emph{Also also note:} The negative form of @samp{-malign-double}
-is @samp{-mno-align-double}, not @samp{-benign-double}.
+@emph{Also also note:} The negative form of @option{-malign-double}
+is @option{-mno-align-double}, not @option{-benign-double}.
@cindex -ffloat-store option
@cindex options, -ffloat-store
This option is effective when the floating-point unit is set to work in
IEEE 854 `extended precision'---as it typically is on x86 and m68k GNU
-systems---rather than IEEE 754 double precision. @samp{-ffloat-store}
+systems---rather than IEEE 754 double precision. @option{-ffloat-store}
tries to remove the extra precision by spilling data from floating-point
registers into memory and this typically involves a big performance
hit. However, it doesn't affect intermediate results, so that it is
@item -fno-inline
@cindex in-line code
@cindex compilation, in-line
-@c DL: Only relevant for -O3?
+@c DL: Only relevant for -O3? TM: No, statement functions are
+@c inlined even at -O1.
Don't compile statement functions inline.
Might reduce the size of a program unit---which might be at
expense of some speed (though it should compile faster).
@cindex conformance, IEEE 754
Might allow some programs designed to not be too dependent
on IEEE behavior for floating-point to run faster, or die trying.
-Sets @samp{-funsafe-math-optimizations}, and
-@samp{-fno-trapping-math}.
+Sets @option{-funsafe-math-optimizations}, and
+@option{-fno-trapping-math}.
@cindex -funsafe-math-optimizations option
@cindex options, -funsafe-math-optimizations
@c DL: Check my understanding of -funroll-all-loops v. -funroll-loops is correct.
Probably improves performance on code using @code{DO WHILE} loops by
unrolling them in addition to iterative @code{DO} loops. In the absence
-of @code{DO WHILE}, this option is equivalent to @samp{-funroll-loops}
+of @code{DO WHILE}, this option is equivalent to @option{-funroll-loops}
but possibly slower.
@item -fno-move-all-movables
@cindex options, -fno-rerun-loop-opt
@emph{Version info:}
These options are not supported by
-versions of @code{g77} based on @code{gcc} version 2.8.
+versions of @command{g77} based on @command{gcc} version 2.8.
Each of these might improve performance on some code.
We're particularly interested in code that runs faster
when these options are @emph{disabled}, and in
non-Fortran code that benefits when they are
-@emph{enabled} via the above @code{gcc} command-line options.
+@emph{enabled} via the above @command{gcc} command-line options.
@end table
@xref{Optimize Options,,Options That Control Optimization,
@cindex INCLUDE directive
@cindex directive, INCLUDE
-Some of these options also affect how @code{g77} processes the
+Some of these options also affect how @command{g77} processes the
@code{INCLUDE} directive.
Since this directive is processed even when preprocessing
is not requested, it is not described in this section.
@xref{Directory Options,,Options for Directory Search}, for
-information on how @code{g77} processes the @code{INCLUDE} directive.
+information on how @command{g77} processes the @code{INCLUDE} directive.
However, the @code{INCLUDE} directive does not apply
preprocessing to the contents of the included file itself.
@cindex INCLUDE directive
@cindex directive, INCLUDE
-Some of these options also affect how @code{g77} searches
+Some of these options also affect how @command{g77} searches
for files specified via the @code{INCLUDE} directive,
although files included by that directive are not,
themselves, preprocessed.
These options are:
-@table @code
+@table @gcctabopt
@cindex -I- option
@cindex options, -I-
@item -I-
(as well as of the @code{#include} directive of the @code{cpp}
preprocessor).
-Note that @samp{-I@var{dir}} must be specified @emph{without} any
-spaces between @samp{-I} and the directory name---that is,
-@samp{-Ifoo/bar} is valid, but @samp{-I foo/bar}
-is rejected by the @code{g77} compiler (though the preprocessor supports
+Note that @option{-I@var{dir}} must be specified @emph{without} any
+spaces between @option{-I} and the directory name---that is,
+@option{-Ifoo/bar} is valid, but @option{-I foo/bar}
+is rejected by the @command{g77} compiler (though the preprocessor supports
the latter form).
@c this is due to toplev.c's inflexible option processing
-Also note that the general behavior of @samp{-I} and
-@code{INCLUDE} is pretty much the same as of @samp{-I} with
+Also note that the general behavior of @option{-I} and
+@code{INCLUDE} is pretty much the same as of @option{-I} with
@code{#include} in the @code{cpp} preprocessor, with regard to
looking for @file{header.gcc} files and other such things.
@xref{Directory Options,,Options for Directory Search,
-gcc,Using and Porting GNU CC}, for information on the @samp{-I} option.
+gcc,Using and Porting GNU CC}, for information on the @option{-I} option.
@end table
@node Code Gen Options
used in code generation.
Most of them have both positive and negative forms; the negative form
-of @samp{-ffoo} would be @samp{-fno-foo}. In the table below, only
+of @option{-ffoo} would be @option{-fno-foo}. In the table below, only
one of the forms is listed---the one which is not the default. You
-can figure out the other form by either removing @samp{no-} or adding
+can figure out the other form by either removing @option{no-} or adding
it.
-@table @code
+@table @gcctabopt
@cindex -fno-automatic option
@cindex options, -fno-automatic
@item -fno-automatic
for every local variable and array referenced in it.
Does not affect common blocks.
(Some Fortran compilers provide this option under
-the name @samp{-static}.)
+the name @option{-static}.)
@cindex -finit-local-zero option
@cindex options, -finit-local-zero
Since there is a run-time penalty for initialization of variables
that are not given the @code{SAVE} attribute, it might be a
-good idea to also use @samp{-fno-automatic} with @samp{-finit-local-zero}.
+good idea to also use @option{-fno-automatic} with @option{-finit-local-zero}.
@cindex -fno-f2c option
@cindex options, -fno-f2c
@item -fno-f2c
-@cindex @code{f2c} compatibility
-@cindex compatibility, @code{f2c}
+@cindex @command{f2c} compatibility
+@cindex compatibility, @command{f2c}
Do not generate code designed to be compatible with code generated
-by @code{f2c}; use the GNU calling conventions instead.
+by @command{f2c} use the GNU calling conventions instead.
-The @code{f2c} calling conventions require functions that return
+The @command{f2c} calling conventions require functions that return
type @code{REAL(KIND=1)} to actually return the C type @code{double},
and functions that return type @code{COMPLEX} to return the
values via an extra argument in the calling sequence that points
This does not affect the generation of code that interfaces with the
@code{libg2c} library.
-However, because the @code{libg2c} library uses @code{f2c}
-calling conventions, @code{g77} rejects attempts to pass
+However, because the @code{libg2c} library uses @command{f2c}
+calling conventions, @command{g77} rejects attempts to pass
intrinsics implemented by routines in this library as actual
-arguments when @samp{-fno-f2c} is used, to avoid bugs when
+arguments when @option{-fno-f2c} is used, to avoid bugs when
they are actually called by code expecting the GNU calling
conventions to work.
For example, @samp{INTRINSIC ABS;CALL FOO(ABS)} is
-rejected when @samp{-fno-f2c} is in force.
-(Future versions of the @code{g77} run-time library might
+rejected when @option{-fno-f2c} is in force.
+(Future versions of the @command{g77} run-time library might
offer routines that provide GNU-callable versions of the
-routines that implement the @code{f2c}-callable intrinsics
+routines that implement the @command{f2c} intrinsics
that may be passed as actual arguments, so that
-valid programs need not be rejected when @samp{-fno-f2c}
+valid programs need not be rejected when @option{-fno-f2c}
is used.)
-@strong{Caution:} If @samp{-fno-f2c} is used when compiling any
+@strong{Caution:} If @option{-fno-f2c} is used when compiling any
source file used in a program, it must be used when compiling
@emph{all} Fortran source files used in that program.
@item -ff2c-library
Specify that use of @code{libg2c} (or the original @code{libf2c})
is required.
-This is the default for the current version of @code{g77}.
+This is the default for the current version of @command{g77}
Currently it is not
-valid to specify @samp{-fno-f2c-library}.
+valid to specify @option{-fno-f2c-library}.
This option is provided so users can specify it in shell
scripts that build programs and libraries that require the
@code{libf2c} library, even when being compiled by future
-versions of @code{g77} that might otherwise default to
+versions of @command{g77} that might otherwise default to
generating code for an incompatible library.
@cindex -fno-underscoring option
Do not transform names of entities specified in the Fortran
source file by appending underscores to them.
-With @samp{-funderscoring} in effect, @code{g77} appends two underscores
+With @option{-funderscoring} in effect, @command{g77} appends two underscores
to names with underscores and one underscore to external names with
-no underscores. (@code{g77} also appends two underscores to internal
+no underscores. (@command{g77} also appends two underscores to internal
names with underscores to avoid naming collisions with external names.
-The @samp{-fno-second-underscore} option disables appending of the
+The @option{-fno-second-underscore} option disables appending of the
second underscore in all cases.)
This is done to ensure compatibility with code produced by many
-UNIX Fortran compilers, including @code{f2c}, which perform the
+UNIX Fortran compilers, including @command{f2c} which perform the
same transformations.
-Use of @samp{-fno-underscoring} is not recommended unless you are
+Use of @option{-fno-underscoring} is not recommended unless you are
experimenting with issues such as integration of (GNU) Fortran into
existing system environments (vis-a-vis existing libraries, tools, and
so on).
-For example, with @samp{-funderscoring}, and assuming other defaults like
-@samp{-fcase-lower} and that @samp{j()} and @samp{max_count()} are
+For example, with @option{-funderscoring}, and assuming other defaults like
+@option{-fcase-lower} and that @samp{j()} and @samp{max_count()} are
external functions while @samp{my_var} and @samp{lvar} are local variables,
a statement like
i = j_() + max_count__(&my_var__, &lvar);
@end smallexample
-With @samp{-fno-underscoring}, the same statement is implemented as:
+With @option{-fno-underscoring}, the same statement is implemented as:
@smallexample
i = j() + max_count(&my_var, &lvar);
@end smallexample
-Use of @samp{-fno-underscoring} allows direct specification of
-user-defined names while debugging and when interfacing @code{g77}-compiled
+Use of @option{-fno-underscoring} allows direct specification of
+user-defined names while debugging and when interfacing @command{g77}
code with other languages.
Note that just because the names match does @emph{not} mean that the
-interface implemented by @code{g77} for an external name matches the
+interface implemented by @command{g77} for an external name matches the
interface implemented by some other language for that same name.
-That is, getting code produced by @code{g77} to link to code produced
+That is, getting code produced by @command{g77} to link to code produced
by some other compiler using this or any other method can be only a
small part of the overall solution---getting the code generated by
both compilers to agree on issues other than naming can require
significant effort, and, unlike naming disagreements, linkers normally
cannot detect disagreements in these other areas.
-Also, note that with @samp{-fno-underscoring}, the lack of appended
+Also, note that with @option{-fno-underscoring}, the lack of appended
underscores introduces the very real possibility that a user-defined
external name will conflict with a name in a system library, which
could make finding unresolved-reference bugs quite difficult in some
cases---they might occur at program run time, and show up only as
buggy behavior at run time.
-In future versions of @code{g77}, we hope to improve naming and linking
+In future versions of @command{g77} we hope to improve naming and linking
issues so that debugging always involves using the names as they appear
in the source, even if the names as seen by the linker are mangled to
prevent accidental linking between procedures with incompatible
Do not append a second underscore to names of entities specified
in the Fortran source file.
-This option has no effect if @samp{-fno-underscoring} is
+This option has no effect if @option{-fno-underscoring} is
in effect.
Otherwise, with this option, an external name such as @samp{MAX_COUNT}
@item -fzeros
Treat initial values of zero as if they were any other value.
-As of version 0.5.18, @code{g77} normally treats @code{DATA} and
+As of version 0.5.18, @command{g77} normally treats @code{DATA} and
other statements that are used to specify initial values of zero
for variables and arrays as if no values were actually specified,
in the sense that no diagnostics regarding multiple initializations
This is done to speed up compiling of programs that initialize
large arrays to zeros.
-Use @samp{-fzeros} to revert to the simpler, slower behavior
+Use @option{-fzeros} to revert to the simpler, slower behavior
that can catch multiple initializations by keeping track of
all initializations, zero or otherwise.
-@emph{Caution:} Future versions of @code{g77} might disregard this option
+@emph{Caution:} Future versions of @command{g77} might disregard this option
(and its negative form, the default) or interpret it somewhat
differently.
The interpretation changes will affect only non-standard
@item -femulate-complex
Implement @code{COMPLEX} arithmetic via emulation,
instead of using the facilities of
-the @code{gcc} back end that provide direct support of
+the @command{gcc} back end that provide direct support of
@code{complex} arithmetic.
-(@code{gcc} had some bugs in its back-end support
+(@command{gcc} had some bugs in its back-end support
for @code{complex} arithmetic, due primarily to the support not being
completed as of version 2.8.1 and @code{egcs} 1.1.2.)
-Use @samp{-femulate-complex} if you suspect code-generation bugs,
+Use @option{-femulate-complex} if you suspect code-generation bugs,
or experience compiler crashes,
-that might result from @code{g77} using the @code{COMPLEX} support
-in the @code{gcc} back end.
+that might result from @command{g77} using the @code{COMPLEX} support
+in the @command{gcc} back end.
If using that option fixes the bugs or crashes you are seeing,
-that indicates a likely @code{g77} bugs
+that indicates a likely @command{g77} bugs
(though, all compiler crashes are considered bugs),
so, please report it.
(Note that the known bugs, now believed fixed, produced compiler crashes
rather than causing the generation of incorrect code.)
Use of this option should not affect how Fortran code compiled
-by @code{g77} works in terms of its interfaces to other code,
-e.g. that compiled by @code{f2c}.
+by @command{g77} works in terms of its interfaces to other code,
+e.g. that compiled by @command{f2c}
+
+As of GCC version 3.0, this option is not necessary anymore.
-@emph{Caution:} Future versions of @code{g77} might ignore both forms
+@emph{Caution:} Future versions of @command{g77} might ignore both forms
of this option.
@cindex -falias-check option
@item -fno-argument-noalias-global
@emph{Version info:}
These options are not supported by
-versions of @code{g77} based on @code{gcc} version 2.8.
+versions of @command{g77} based on @command{gcc} version 2.8.
These options specify to what degree aliasing
(overlap)
public) storage.
The default for Fortran code, as mandated by the FORTRAN 77 and
-Fortran 90 standards, is @samp{-fargument-noalias-global}.
+Fortran 90 standards, is @option{-fargument-noalias-global}.
The default for code written in the C language family is
-@samp{-fargument-alias}.
+@option{-fargument-alias}.
-Note that, on some systems, compiling with @samp{-fforce-addr} in
+Note that, on some systems, compiling with @option{-fforce-addr} in
effect can produce more optimal code when the default aliasing
options are in effect (and when optimization is enabled).
to inline a reference to a procedure within a
program unit.
(The diagnostics themselves are still produced, but
-as warnings, unless @samp{-Wno-globals} is specified,
+as warnings, unless @option{-Wno-globals} is specified,
in which case no relevant diagnostics are produced.)
Further, this option disables such inlining, to
As such, this option might be quite useful when
compiling existing, ``working'' code that happens
to have a few bugs that do not generally show themselves,
-but which @code{g77} diagnoses.
+but which @command{g77} diagnoses.
Use of this option therefore has the effect of
-instructing @code{g77} to behave more like it did
+instructing @command{g77} to behave more like it did
up through version 0.5.19.1, when it paid little or
no attention to disagreements between program units
about a procedure's type and argument information,
and when it performed no inlining of procedures
(except statement functions).
-Without this option, @code{g77} defaults to performing
+Without this option, @command{g77} defaults to performing
the potentially inlining procedures as it started doing
in version 0.5.20, but as of version 0.5.21, it also
diagnoses disagreements that might cause such inlining
to handle all array references.
@emph{Note:} This option is not supported.
-It is intended for use only by @code{g77} developers,
+It is intended for use only by @command{g77} developers,
to evaluate code-generation issues.
It might be removed at any time.
The current implementation uses the @code{libf2c}
library routine @code{s_rnge} to print the diagnostic.
-However, whereas @code{f2c} generates a single check per
+However, whereas @command{f2c} generates a single check per
reference for a multi-dimensional array, of the computed
offset against the valid offset range (0 through the size of the array),
-@code{g77} generates a single check per @emph{subscript} expression.
-This catches some cases of potential bugs that @code{f2c} does not,
+@command{g77} generates a single check per @emph{subscript} expression.
+This catches some cases of potential bugs that @command{f2c} does not,
such as references to below the beginning of an assumed-size array.
-@code{g77} also generates checks for @code{CHARACTER} substring references,
-something @code{f2c} currently does not do.
+@command{g77} also generates checks for @code{CHARACTER} substring references,
+something @command{f2c} currently does not do.
-Use the new @samp{-ffortran-bounds-check} option
+Use the new @option{-ffortran-bounds-check} option
to specify bounds-checking for only the Fortran code you are compiling,
not necessarily for code written in other languages.
@emph{Note:} To provide more detailed information on the offending subscript,
-@code{g77} provides the @code{libg2c} run-time library routine @code{s_rnge}
+@command{g77} provides the @code{libg2c} run-time library routine @code{s_rnge}
with somewhat differently-formatted information.
Here's a sample diagnostic:
and the offending substring expression is @samp{11}.
(Though the verbage of @code{s_rnge} is not ideal
-for the purpose of the @code{g77} compiler,
+for the purpose of the @command{g77} compiler,
the above information should provide adequate diagnostic abilities
to it users.)
@end table
@xref{Code Gen Options,,Options for Code Generation Conventions,
gcc,Using and Porting GNU CC}, for information on more options
offered by the GBE
-shared by @code{g77}, @code{gcc}, and other GNU compilers.
+shared by @command{g77} @command{gcc} and other GNU compilers.
Some of these do @emph{not} work when compiling programs written in Fortran:
-@table @code
+@table @gcctabopt
@cindex -fpcc-struct-return option
@cindex options, -fpcc-struct-return
@item -fpcc-struct-return
@item -freg-struct-return
You should not use these except strictly the same way as you
used them to build the version of @code{libg2c} with which
-you will be linking all code compiled by @code{g77} with the
+you will be linking all code compiled by @command{g77} with the
same option.
@cindex -fshort-double option
GNU Fortran currently does not make use of any environment
variables to control its operation above and beyond those
-that affect the operation of @code{gcc}.
+that affect the operation of @command{gcc}.
@xref{Environment Variables,,Environment Variables Affecting GNU CC,
gcc,Using and Porting GNU CC}, for information on environment
OSDN Git Service
