@c %**start of header
@setfilename g77.info
-@set last-update 1999-05-26
-@set copyrights-g77 1995-1999
+@set last-update 2002-04-29
+@set copyrights-g77 1995,1996,1997,1998,1999,2000,2001,2002
@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
Copyright (C) @value{copyrights-g77} Free Software Foundation, Inc.
-Permission is granted to make and distribute verbatim copies of
-this manual provided the copyright notice and this permission notice
-are preserved on all copies.
-
-@ignore
-Permission is granted to process this file through Tex and print the
-results, provided the printed document carries copying permission
-notice identical to this one except for the removal of this paragraph
-(this paragraph not being relevant to the printed manual).
-
-@end ignore
-Permission is granted to copy and distribute modified versions of this
-manual under the conditions for verbatim copying, provided also that the
-sections entitled ``GNU General Public License,'' ``Funding for Free
-Software,'' and ``Protect Your Freedom---Fight `Look And Feel'@w{}'' are
-included exactly as in the original, and provided that the entire
-resulting derived work is distributed under the terms of a permission
-notice identical to this one.
-
-Permission is granted to copy and distribute translations of this manual
-into another language, under the above conditions for modified versions,
-except that the sections entitled ``GNU General Public License,''
-``Funding for Free Software,'' and ``Protect Your Freedom---Fight `Look
-And Feel'@w{}'', and this permission notice, may be included in
-translations approved by the Free Software Foundation instead of in the
-original English.
+
+Permission is granted to copy, distribute and/or modify this document
+under the terms of the GNU Free Documentation License, Version 1.1 or
+any later version published by the Free Software Foundation; with the
+Invariant Sections being ``GNU General Public License'' and ``Funding
+Free Software'', the Front-Cover
+texts being (a) (see below), and with the Back-Cover Texts being (b)
+(see below). A copy of the license is included in the section entitled
+``GNU Free Documentation License''.
+
+(a) The FSF's Front-Cover Text is:
+
+ A GNU Manual
+
+(b) The FSF's Back-Cover Text is:
+
+ You have freedom to copy and modify this GNU Manual, like GNU
+ software. Copies published by the Free Software Foundation raise
+ funds for GNU development.
@end ifinfo
Contributed by James Craig Burley (@email{@value{email-burley}}).
@sp 3
@center Last updated @value{last-update}
@sp 1
-@center for version @value{version-g77}
+@center for version @value{which-g77}
@page
@vskip 0pt plus 1filll
Copyright @copyright{} @value{copyrights-g77} Free Software Foundation, Inc.
@c Printed copies are available for $? each.@*
@c ISBN ???
@sp 1
-Permission is granted to make and distribute verbatim copies of
-this manual provided the copyright notice and this permission notice
-are preserved on all copies.
-
-Permission is granted to copy and distribute modified versions of this
-manual under the conditions for verbatim copying, provided also that the
-sections entitled ``GNU General Public License,'' ``Funding for Free
-Software,'' and ``Protect Your Freedom---Fight `Look And Feel'@w{}'' are
-included exactly as in the original, and provided that the entire
-resulting derived work is distributed under the terms of a permission
-notice identical to this one.
-
-Permission is granted to copy and distribute translations of this manual
-into another language, under the above conditions for modified versions,
-except that the sections entitled ``GNU General Public License,''
-``Funding for Free Software,'' and ``Protect Your Freedom---Fight `Look
-And Feel'@w{}'', and this permission notice, may be included in
-translations approved by the Free Software Foundation instead of in the
-original English.
+Permission is granted to copy, distribute and/or modify this document
+under the terms of the GNU Free Documentation License, Version 1.1 or
+any later version published by the Free Software Foundation; with the
+Invariant Sections being ``GNU General Public License'' and ``Funding
+Free Software'', the Front-Cover
+texts being (a) (see below), and with the Back-Cover Texts being (b)
+(see below). A copy of the license is included in the section entitled
+``GNU Free Documentation License''.
+
+(a) The FSF's Front-Cover Text is:
+
+ A GNU Manual
+
+(b) The FSF's Back-Cover Text is:
+
+ You have freedom to copy and modify this GNU Manual, like GNU
+ software. Copies published by the Free Software Foundation raise
+ funds for GNU development.
@end titlepage
+@summarycontents
+@contents
@page
-@ifinfo
-
@node Top, Copying,, (DIR)
@top Introduction
@cindex Introduction
@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
* Copying:: GNU General Public License says
how you can copy and share GNU Fortran.
+* GNU Free Documentation License::
+ How you can copy and share this manual.
* Contributors:: People who have contributed to GNU Fortran.
* Funding:: How to help assure continued work for free software.
* Funding GNU Fortran:: How to help assure continued work on GNU Fortran.
-* Look and Feel:: Protect your freedom---fight ``look and feel''.
@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.
-* Installation:: How to configure, compile and install GNU 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
@c yes, the "M: " @emph{is} intentional -- bad.def references it (CMPAMBIG)!
-@node Copying
-@unnumbered GNU GENERAL PUBLIC LICENSE
-@center Version 2, June 1991
-
-@display
-Copyright @copyright{} 1989, 1991 Free Software Foundation, Inc.
-59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
-
-Everyone is permitted to copy and distribute verbatim copies
-of this license document, but changing it is not allowed.
-@end display
-
-@unnumberedsec Preamble
-
- The licenses for most software are designed to take away your
-freedom to share and change it. By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software---to make sure the software is free for all its users. This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it. (Some other Free Software Foundation software is covered by
-the GNU Library General Public License instead.) You can apply it to
-your programs, too.
-
- When we speak of free software, we are referring to freedom, not
-price. Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
- To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
- For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have. You must make sure that they, too, receive or can get the
-source code. And you must show them these terms so they know their
-rights.
-
- We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
- Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software. If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
- Finally, any free program is threatened constantly by software
-patents. We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary. To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
- The precise terms and conditions for copying, distribution and
-modification follow.
-
-@iftex
-@unnumberedsec TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-@end iftex
-@ifinfo
-@center TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-@end ifinfo
-
-@enumerate 0
-@item
-This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License. The ``Program'', below,
-refers to any such program or work, and a ``work based on the Program''
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language. (Hereinafter, translation is included without limitation in
-the term ``modification''.) Each licensee is addressed as ``you''.
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope. The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-@item
-You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-@item
-You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-@enumerate a
-@item
-You must cause the modified files to carry prominent notices
-stating that you changed the files and the date of any change.
-
-@item
-You must cause any work that you distribute or publish, that in
-whole or in part contains or is derived from the Program or any
-part thereof, to be licensed as a whole at no charge to all third
-parties under the terms of this License.
-
-@item
-If the modified program normally reads commands interactively
-when run, you must cause it, when started running for such
-interactive use in the most ordinary way, to print or display an
-announcement including an appropriate copyright notice and a
-notice that there is no warranty (or else, saying that you provide
-a warranty) and that users may redistribute the program under
-these conditions, and telling the user how to view a copy of this
-License. (Exception: if the Program itself is interactive but
-does not normally print such an announcement, your work based on
-the Program is not required to print an announcement.)
-@end enumerate
-
-These requirements apply to the modified work as a whole. If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works. But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-@item
-You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-@enumerate a
-@item
-Accompany it with the complete corresponding machine-readable
-source code, which must be distributed under the terms of Sections
-1 and 2 above on a medium customarily used for software interchange; or,
-
-@item
-Accompany it with a written offer, valid for at least three
-years, to give any third party, for a charge no more than your
-cost of physically performing source distribution, a complete
-machine-readable copy of the corresponding source code, to be
-distributed under the terms of Sections 1 and 2 above on a medium
-customarily used for software interchange; or,
-
-@item
-Accompany it with the information you received as to the offer
-to distribute corresponding source code. (This alternative is
-allowed only for noncommercial distribution and only if you
-received the program in object code or executable form with such
-an offer, in accord with Subsection b above.)
-@end enumerate
-
-The source code for a work means the preferred form of the work for
-making modifications to it. For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable. However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-@item
-You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License. Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-@item
-You are not required to accept this License, since you have not
-signed it. However, nothing else grants you permission to modify or
-distribute the Program or its derivative works. These actions are
-prohibited by law if you do not accept this License. Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-@item
-Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions. You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-@item
-If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License. If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all. For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices. Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-@item
-If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded. In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-@item
-The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time. Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number. If the Program
-specifies a version number of this License which applies to it and ``any
-later version'', you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation. If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-@item
-If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission. For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this. Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-@iftex
-@heading NO WARRANTY
-@end iftex
-@ifinfo
-@center NO WARRANTY
-@end ifinfo
-
-@item
-BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM ``AS IS'' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-@item
-IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-@end enumerate
-
-@iftex
-@heading END OF TERMS AND CONDITIONS
-@end iftex
-@ifinfo
-@center END OF TERMS AND CONDITIONS
-@end ifinfo
-
-@page
-@unnumberedsec How to Apply These Terms to Your New Programs
+@include gpl.texi
- If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
- To do so, attach the following notices to the program. It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the ``copyright'' line and a pointer to where the full notice is found.
-
-@smallexample
-@var{one line to give the program's name and a brief idea of what it does.}
-Copyright (C) 19@var{yy} @var{name of author}
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-@end smallexample
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-@smallexample
-Gnomovision version 69, Copyright (C) 19@var{yy} @var{name of author}
-Gnomovision comes with ABSOLUTELY NO WARRANTY; for details
-type `show w'.
-This is free software, and you are welcome to redistribute it
-under certain conditions; type `show c' for details.
-@end smallexample
-
-The hypothetical commands @samp{show w} and @samp{show c} should show
-the appropriate parts of the General Public License. Of course, the
-commands you use may be called something other than @samp{show w} and
-@samp{show c}; they could even be mouse-clicks or menu items---whatever
-suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a ``copyright disclaimer'' for the program, if
-necessary. Here is a sample; alter the names:
-
-@smallexample
-Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-`Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-@var{signature of Ty Coon}, 1 April 1989
-Ty Coon, President of Vice
-@end smallexample
-
-This General Public License does not permit incorporating your program into
-proprietary programs. If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library. If this is what you want to do, use the GNU Library General
-Public License instead of this License.
+@include fdl.texi
@node Contributors
@unnumbered Contributors to GNU Fortran
@item
The packaging and compiler portions of GNU Fortran are based largely
on the GNU CC compiler.
-@xref{Contributors,,Contributors to GNU CC,gcc,Using and Porting GNU CC},
+@xref{Contributors,,Contributors to GCC,gcc,Using the GNU Compiler
+Collection (GCC)},
for more information.
@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
@code{LOGICAL*1}.
This inspired Craig to add further support,
even though the resulting support
-would still be incomplete, because version 0.6 is still
-a ways off.
+would still be incomplete.
@item
David Ronis (@email{ronis@@onsager.chem.mcgill.ca}) inspired
@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, have 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}.)
+(These, in turn, had made their way into the @code{egcs}
+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
The default is that people wish to remain anonymous.
@end itemize
-@node Funding
-@chapter Funding Free Software
-
-If you want to have more free software a few years from now, it makes
-sense for you to help encourage people to contribute funds for its
-development. The most effective approach known is to encourage
-commercial redistributors to donate.
-
-Users of free software systems can boost the pace of development by
-encouraging for-a-fee distributors to donate part of their selling price
-to free software developers---the Free Software Foundation, and others.
-
-The way to convince distributors to do this is to demand it and expect
-it from them. So when you compare distributors, judge them partly by
-how much they give to free software development. Show distributors
-they must compete to be the one who gives the most.
-
-To make this approach work, you must insist on numbers that you can
-compare, such as, ``We will donate ten dollars to the Frobnitz project
-for each disk sold.'' Don't be satisfied with a vague promise, such as
-``A portion of the profits are donated,'' since it doesn't give a basis
-for comparison.
-
-Even a precise fraction ``of the profits from this disk'' is not very
-meaningful, since creative accounting and unrelated business decisions
-can greatly alter what fraction of the sales price counts as profit.
-If the price you pay is $50, ten percent of the profit is probably
-less than a dollar; it might be a few cents, or nothing at all.
-
-Some redistributors do development work themselves. This is useful too;
-but to keep everyone honest, you need to inquire how much they do, and
-what kind. Some kinds of development make much more long-term
-difference than others. For example, maintaining a separate version of
-a program contributes very little; maintaining the standard version of a
-program for the whole community contributes much. Easy new ports
-contribute little, since someone else would surely do them; difficult
-ports such as adding a new CPU to the GNU C compiler contribute more;
-major new features or packages contribute the most.
-
-By establishing the idea that supporting further development is ``the
-proper thing to do'' when distributing free software for a fee, we can
-assure a steady flow of resources into making more free software.
-
-@display
-Copyright (C) 1994 Free Software Foundation, Inc.
-Verbatim copying and redistribution of this section is permitted
-without royalty; alteration is not permitted.
-@end display
+@include funding.texi
@node Funding GNU Fortran
@chapter Funding GNU Fortran
@cindex funding improvements
@cindex improvements, funding
-Work on GNU Fortran is still being done mostly by its author,
-James Craig Burley (@email{@value{email-burley}}), who is a volunteer
-for, not an employee of, the Free Software Foundation (FSF).
+James Craig Burley (@email{@value{email-burley}}), the original author
+of @command{g77}, stopped working on it in September 1999
(He has a web page at @uref{@value{www-burley}}.)
+GNU Fortran is currently maintained by Toon Moene
+(@email{toon@@moene.indiv.nluug.nl}), with the help of countless other
+volunteers.
+
As with other GNU software, funding is important because it can pay for
needed equipment, personnel, and so on.
such as the ``GNUS Bulletin''.
Email @email{gnu@@gnu.org} for information on funding the FSF.
-To fund specific GNU Fortran work in particular, the FSF might
-provide a means for that, but the FSF does not provide direct funding
-to the author of GNU Fortran to continue his work. The FSF has
-employee salary restrictions that can be incompatible with the
-financial needs of some volunteers, who therefore choose to
-remain volunteers and thus be able to be free to do contract work
-and otherwise make their own schedules for doing GNU work.
-
-Still, funding the FSF at least indirectly benefits work
-on specific projects like GNU Fortran because it ensures the
-continuing operation of the FSF offices, their workstations, their
-network connections, and so on, which are invaluable to volunteers.
-(Similarly, hiring Cygnus Support can help a project like GNU
-Fortran---Cygnus has been a long-time donor of equipment usage to the author
-of GNU Fortran, and this too has been invaluable---see @ref{Contributors}.)
-
-Currently, the only way to directly fund the author of GNU Fortran
-in his work on that project is to hire him for the work you want
-him to do, or donate money to him.
-Several people have done this
-already, with the result that he has not needed to immediately find
-contract work on a few occasions.
-If more people did this, he
-would be able to plan on not doing contract work for many months and
-could thus devote that time to work on projects (such as the planned
-changes for 0.6) that require longer timeframes to complete.
-For the latest information on the status of the author, do
-@kbd{finger -l burley@@gnu.org} on a UNIX system
-(or any system with a command like UNIX @code{finger}).
-
Another important way to support work on GNU Fortran is to volunteer
to help out.
-Work is needed on documentation, testing, porting
-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.
-
-@xref{Funding,,Funding Free Software}, for more information.
-@node Look and Feel
-@chapter Protect Your Freedom---Fight ``Look And Feel''
-@c the above chapter heading overflows onto the next line. --mew 1/26/93
+Email @email{@value{email-general}} to volunteer for this work.
-To preserve the ability to write free software, including replacements
-for proprietary software, authors must be free to replicate the
-user interface to which users of existing software have become
-accustomed.
+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{Look and Feel,,Protect Your Freedom---Fight ``Look And Feel'',
-gcc,Using and Porting GNU CC}, for more information.
+@xref{Funding,,Funding Free Software}, for more information.
@node Getting Started
@chapter 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
not already strictly conforming ANSI FORTRAN 77---and this
is probably everyone---you should see @ref{Language}.
-If you don't already have @code{g77} installed on your
-system, you must see @ref{Installation}.
-
If you run into trouble getting Fortran code to compile,
link, run, or work properly, you might find answers
if you see @ref{Debugging and Interfacing},
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
-for, or alternative to, the UNIX @code{f77} command.
-(Similarly, @code{gcc} is designed as a replacement
-for the UNIX @code{cc} command.)
+GNU Fortran, or @command{g77}, is designed initially as a free replacement
+for, or alternative to, the UNIX @command{f77} command.
+(Similarly, @command{gcc} is designed as a replacement
+for the UNIX @command{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 @command{f77}
share the following characteristics:
@itemize @bullet
@cindex debugger
@cindex bugs, finding
-@cindex @code{gdb}, command
-@cindex commands, @code{gdb}
+@cindex @command{gdb}, command
+@cindex commands, @command{gdb}
@item
They provide information in the generated machine code
that can make it easier to find bugs in the program
(using a debugging tool, called a @dfn{debugger},
-such as @code{gdb}).
+such as @command{gdb}).
@cindex libraries
@cindex linking
-@cindex @code{ld} command
-@cindex commands, @code{ld}
+@cindex @command{ld} command
+@cindex commands, @command{ld}
@item
They locate and gather machine code already generated
to perform actions requested by statements in
process.
(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}
+@command{ld} command.
+However, the @command{g77} and @command{gcc}
commands, as with most compiler commands, automatically
-perform the linking step by calling on @code{ld}
+perform the linking step by calling on @command{ld}
directly, unless asked to not do so by the user.)
@cindex language, incorrect use of
of the language), how much time to spend making
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 components of @command{g77}
+@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
-installed as the system's @code{cc} command.
-(In many cases, @code{cc} refers to the
+A modified version of the @command{gcc} command, which also might be
+installed as the system's @command{cc} command.
+(In many cases, @command{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
-system's @code{f77} command.
+The @command{g77} command itself, which also might be installed as the
+system's @command{f77} command.
@cindex libg2c library
@cindex libf2c 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.
@cindex @code{f771}, program
@cindex programs, @code{f771}
@cindex assembler
-@cindex @code{as} command
-@cindex commands, @code{as}
+@cindex @command{as} command
+@cindex commands, @command{as}
@cindex assembly code
@cindex code, assembly
@item
Note that @code{f771} does not generate machine code directly---it
generates @dfn{assembly code} that is a more readable form
of machine code, leaving the conversion to actual machine code
-to an @dfn{assembler}, usually named @code{as}.
+to an @dfn{assembler}, usually named @command{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 cpp program
@cindex programs, cpp
For example, the command @samp{gcc foo.c} @dfn{drives} the file
-@file{foo.c} through the preprocessor @code{cpp}, then
+@file{foo.c} through the preprocessor @command{cpp}, then
the C compiler (internally named
-@code{cc1}), then the assembler (usually @code{as}), then the linker
-(@code{ld}), producing an executable program named @file{a.out} (on
+@code{cc1}), then the assembler (usually @command{as}), then the linker
+(@command{ld}), producing an executable program named @file{a.out} (on
UNIX systems).
-@cindex cc1plus 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}).
-
-@cindex @code{f771}, program
-@cindex programs, @code{f771}
-In a GNU Fortran installation, @code{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 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}
-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}.
-
-@cindex printing version information
-@cindex version information, printing
-The command @samp{g77 -v} is a quick
-way to display lots of version information for the various programs
-used to compile a typical preprocessed Fortran source file---this
-produces much more output than @samp{gcc -v} currently does.
-(If it produces an error message near the end of the output---diagnostics
-from the linker, usually @code{ld}---you might
-have an out-of-date @code{libf2c} that improperly handles
-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.
-
-@cindex libf2c library
-@cindex libraries, libf2c
-The @code{libf2c} library is distributed with GNU Fortran for
-the convenience of its users, but is not part of GNU Fortran.
-It contains the procedures
-needed by Fortran programs while they are running.
-
-@cindex in-line code
-@cindex code, in-line
-For example, while code generated by @code{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
-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
-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},
-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},
-@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 back end, gcc
-@cindex code generator
-One chunk is the so-called @dfn{GNU Back End}, or GBE,
-which knows how to generate fast code for a wide variety of processors.
-The same GBE is used by the C, C++, and Fortran compiler programs @code{cc1},
-@code{cc1plus}, and @code{f771}, plus others.
-Often the GBE is referred to as the ``gcc back end'' or
-even just ``gcc''---in this manual, the term GBE is used
-whenever the distinction is important.
-
-@cindex GNU Fortran Front End (FFE)
-@cindex FFE
-@cindex @code{g77}, front end
-@cindex front end, @code{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
-do, and then communicate that knowledge to the GBE for actual compilation
-of those programs.
-This chunk is called the @dfn{Fortran Front End} (FFE).
-The @code{cc1} and @code{cc1plus} programs have their own front ends,
-for the C and C++ languages, respectively.
-These fronts ends are responsible for diagnosing
-incorrect usage of their respective languages by the
-programs the process, and are responsible for most of
-the warnings about questionable constructs as well.
-(The GBE handles producing some warnings, like those
-concerning possible references to undefined variables.)
-
-Because so much is shared among the compilers for various languages,
-much of the behavior and many of the user-selectable options for these
-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
-of generated code (in terms of speed and size) is roughly similar
-(since that work is done by the shared GBE).
-
-@node G77 and GCC
-@chapter Compile Fortran, C, or Other Programs
-@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}
-command.
-
-In a non-Fortran installation, @code{gcc} recognizes C, C++,
-and Objective-C source files.
-
-In a GNU Fortran installation, @code{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}).
-
-@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
-these tasks.
-It does this by analyzing the command line somewhat and changing it
-appropriately before submitting it to the @code{gcc} command.
-
-@cindex -v option
-@cindex @code{g77} options, -v
-@cindex options, -v
-Use the @samp{-v} option with @code{g77}
-to see what is going on---the first line of output is the invocation
-of the @code{gcc} command.
-
-@node Invoking G77
-@chapter GNU Fortran Command Options
-@cindex GNU Fortran command options
-@cindex command options
-@cindex options, GNU Fortran command
-
-The @code{g77} command supports all the options supported by the
-@code{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).
-
-@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}
-(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
-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}.
-This manual documents only one of these two forms, whichever
-one is not the default.
-
-@menu
-* Option Summary:: Brief list of all @code{g77} options,
- without explanations.
-* Overall Options:: Controlling the kind of output:
- an executable, object files, assembler files,
- or preprocessed source.
-* Shorthand Options:: Options that are shorthand for other options.
-* Fortran Dialect Options:: Controlling the variant of Fortran language
- compiled.
-* Warning Options:: How picky should the compiler be?
-* Debugging Options:: Symbol tables, measurements, and debugging dumps.
-* Optimize Options:: How much optimization?
-* Preprocessor Options:: Controlling header files and macro definitions.
- Also, getting dependency information for Make.
-* Directory Options:: Where to find header files and libraries.
- Where to find the compiler executable files.
-* Code Gen Options:: Specifying conventions for function calls, data layout
- and register usage.
-* Environment Variables:: Env vars that affect GNU Fortran.
-@end menu
-
-@node Option Summary
-@section Option Summary
-
-Here is a summary of all the options specific to GNU Fortran, grouped
-by type. Explanations are in the following sections.
-
-@table @emph
-@item Overall Options
-@xref{Overall Options,,Options Controlling the Kind of Output}.
-@smallexample
--fversion -fset-g77-defaults -fno-silent
-@end smallexample
-
-@item Shorthand Options
-@xref{Shorthand Options}.
-@smallexample
--ff66 -fno-f66 -ff77 -fno-f77 -fno-ugly
-@end smallexample
-
-@item Fortran Language Options
-@xref{Fortran Dialect Options,,Options Controlling Fortran Dialect}.
-@smallexample
--ffree-form -fno-fixed-form -ff90
--fvxt -fdollar-ok -fno-backslash
--fno-ugly-args -fno-ugly-assign -fno-ugly-assumed
--fugly-comma -fugly-complex -fugly-init -fugly-logint
--fonetrip -ftypeless-boz
--fintrin-case-initcap -fintrin-case-upper
--fintrin-case-lower -fintrin-case-any
--fmatch-case-initcap -fmatch-case-upper
--fmatch-case-lower -fmatch-case-any
--fsource-case-upper -fsource-case-lower -fsource-case-preserve
--fsymbol-case-initcap -fsymbol-case-upper
--fsymbol-case-lower -fsymbol-case-any
--fcase-strict-upper -fcase-strict-lower
--fcase-initcap -fcase-upper -fcase-lower -fcase-preserve
--ff2c-intrinsics-delete -ff2c-intrinsics-hide
--ff2c-intrinsics-disable -ff2c-intrinsics-enable
--fbadu77-intrinsics-delete -fbadu77-intrinsics-hide
--fbadu77-intrinsics-disable -fbadu77-intrinsics-enable
--ff90-intrinsics-delete -ff90-intrinsics-hide
--ff90-intrinsics-disable -ff90-intrinsics-enable
--fgnu-intrinsics-delete -fgnu-intrinsics-hide
--fgnu-intrinsics-disable -fgnu-intrinsics-enable
--fmil-intrinsics-delete -fmil-intrinsics-hide
--fmil-intrinsics-disable -fmil-intrinsics-enable
--funix-intrinsics-delete -funix-intrinsics-hide
--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
-
-@item Warning Options
-@xref{Warning Options,,Options to Request or Suppress Warnings}.
-@smallexample
--fsyntax-only -pedantic -pedantic-errors -fpedantic
--w -Wno-globals -Wimplicit -Wunused -Wuninitialized
--Wall -Wsurprising
--Werror -W
-@end smallexample
-
-@item Debugging Options
-@xref{Debugging Options,,Options for Debugging Your Program or GCC}.
-@smallexample
--g
-@end smallexample
-
-@item Optimization Options
-@xref{Optimize Options,,Options that Control Optimization}.
-@smallexample
--malign-double
--ffloat-store -fforce-mem -fforce-addr -fno-inline
--ffast-math -fstrength-reduce -frerun-cse-after-loop
--fexpensive-optimizations -fdelayed-branch
--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
-
-@item Directory Options
-@xref{Directory Options,,Options for Directory Search}.
-@smallexample
--I@var{dir} -I-
-@end smallexample
-
-@item Code Generation Options
-@xref{Code Gen Options,,Options for Code Generation Conventions}.
-@smallexample
--fno-automatic -finit-local-zero -fno-f2c
--ff2c-library -fno-underscoring -fno-ident
--fpcc-struct-return -freg-struct-return
--fshort-double -fno-common -fpack-struct
--fzeros -fno-second-underscore
--fdebug-kludge -femulate-complex
--falias-check -fargument-alias
--fargument-noalias -fno-argument-noalias-global
--fno-globals -fflatten-arrays
--fbounds-check -ffortran-bounds-check
-@end smallexample
-@end table
-
-@menu
-* Overall Options:: Controlling the kind of output:
- an executable, object files, assembler files,
- or preprocessed source.
-* Shorthand Options:: Options that are shorthand for other options.
-* Fortran Dialect Options:: Controlling the variant of Fortran language
- compiled.
-* Warning Options:: How picky should the compiler be?
-* Debugging Options:: Symbol tables, measurements, and debugging dumps.
-* Optimize Options:: How much optimization?
-* Preprocessor Options:: Controlling header files and macro definitions.
- Also, getting dependency information for Make.
-* Directory Options:: Where to find header files and libraries.
- Where to find the compiler executable files.
-* Code Gen Options:: Specifying conventions for function calls, data layout
- and register usage.
-@end menu
-
-@node Overall Options
-@section Options Controlling the Kind of Output
-@cindex overall options
-@cindex options, overall
-
-Compilation can involve as many as four stages: preprocessing, code
-generation (often what is really meant by the term ``compilation''),
-assembly, and linking, always in that order. The first three
-stages apply to an individual source file, and end by producing an
-object file; linking combines all the object files (those newly
-compiled, and those specified as input) into an executable file.
-
-@cindex file name suffix
-@cindex suffixes, file name
-@cindex file name extension
-@cindex extensions, file name
-@cindex file type
-@cindex types, file
-For any given input file, the file name suffix determines what kind of
-program is contained in the file---that is, the language in which the
-program is written is generally indicated by the suffix.
-Suffixes specific to GNU Fortran are listed below.
-@xref{Overall Options,,gcc,Using and Porting GNU CC}, for
-information on suffixes recognized by GNU CC.
-
-@table @code
-@cindex .f filename suffix
-@cindex .for filename suffix
-@cindex .FOR filename suffix
-@item @var{file}.f
-@item @var{file}.for
-@item @var{file}.FOR
-Fortran source code that should not be preprocessed.
-
-Such source code cannot contain any preprocessor directives, such
-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}.
-@xref{LEX}.
-
-@cindex preprocessor
-@cindex C preprocessor
-@cindex cpp preprocessor
-@cindex Fortran preprocessor
-@cindex cpp program
-@cindex programs, cpp
-@cindex .F filename suffix
-@cindex .fpp filename suffix
-@cindex .FPP filename suffix
-@item @var{file}.F
-@item @var{file}.fpp
-@item @var{file}.FPP
-Fortran source code that must be preprocessed (by the C preprocessor
-@code{cpp}, which is part of GNU CC).
-
-Note that preprocessing is not extended to the contents of
-files included by the @code{INCLUDE} directive---the @code{#include}
-preprocessor directive must be used instead.
-
-@cindex Ratfor preprocessor
-@cindex programs, @code{ratfor}
-@cindex @samp{.r} filename suffix
-@cindex @code{ratfor}
-@item @var{file}.r
-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
-@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}.
-@end table
-
-UNIX users typically use the @file{@var{file}.f} and @file{@var{file}.F}
-nomenclature.
-Users of other operating systems, especially those that cannot
-distinguish upper-case
-letters from lower-case letters in their file names, typically use
-the @file{@var{file}.for} and @file{@var{file}.fpp} nomenclature.
-
-@cindex #define
-@cindex #include
-@cindex #if
-Use of the preprocessor @code{cpp} allows use of C-like
-constructs such as @code{#define} and @code{#include}, but can
-lead to unexpected, even mistaken, results due to Fortran's source file
-format.
-It is recommended that use of the C preprocessor
-be limited to @code{#include} and, in
-conjunction with @code{#define}, only @code{#if} and related directives,
-thus avoiding in-line macro expansion entirely.
-This recommendation applies especially
-when using the traditional fixed source form.
-With free source form,
-fewer unexpected transformations are likely to happen, but use of
-constructs such as Hollerith and character constants can nevertheless
-present problems, especially when these are continued across multiple
-source lines.
-These problems result, primarily, from differences between the way
-such constants are interpreted by the C preprocessor and by a Fortran
-compiler.
-
-Another example of a problem that results from using the C preprocessor
-is that a Fortran comment line that happens to contain any
-characters ``interesting'' to the C preprocessor,
-such as a backslash at the end of the line,
-is not recognized by the preprocessor as a comment line,
-so instead of being passed through ``raw'',
-the line is edited according to the rules for the preprocessor.
-For example, the backslash at the end of the line is removed,
-along with the subsequent newline, resulting in the next
-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
-to @code{cpp} by default, to help avoid unpleasant surprises.
-@xref{Preprocessor Options,,Options Controlling the Preprocessor,
-gcc,Using and Porting GNU CC}.
-This means that ANSI C preprocessor features (such as the @samp{#}
-operator) aren't available, and only variables in the C reserved
-namespace (generally, names with a leading underscore) are liable to
-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.
-
-@cindex /*
-Unfortunately, the @samp{-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
-C an inline comment.
-@end smallexample
-@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:
-
-@table @code
-@cindex -fversion option
-@cindex options, -fversion
-@cindex printing version information
-@cindex version information, printing
-@cindex consistency checks
-@cindex internal consistency checks
-@cindex checks, of internal consistency
-@item -fversion
-Ensure that the @code{g77}-specific 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}
-and when the resulting commands compile Fortran source files.
-
-@cindex -fset-g77-defaults option
-@cindex options, -fset-g77-defaults
-@item -fset-g77-defaults
-@emph{Version info:}
-This option is obsolete in @code{egcs}
-as of version 1.1.
-The effect is instead achieved
-by the @code{lang_init_options} routine
-in @file{egcs/gcc/f/com.c}.
-
-@cindex consistency checks
-@cindex internal consistency checks
-@cindex checks, of internal consistency
-Set up whatever @code{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.
-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 modifying g77
-@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}.
-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
-with a diagnostic if it detects an inconsistency.
-
-@cindex -fno-silent option
-@cindex options, -fno-silent
-@cindex f2c compatibility
-@cindex compatibility, f2c
-@cindex status, compilation
-@cindex compilation, status
-@cindex reporting compilation status
-@cindex printing compilation status
-@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}.
-@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).
-
-@node Shorthand Options
-@section Shorthand Options
-@cindex shorthand options
-@cindex options, shorthand
-@cindex macro options
-@cindex options, macro
-
-The following options serve as ``shorthand''
-for other options accepted by the compiler:
-
-@table @code
-@cindex -fugly option
-@cindex options, -fugly
-@item -fugly
-@cindex ugly features
-@cindex features, ugly
-@emph{Note:} This option is no longer supported.
-The information, below, is provided to aid
-in the conversion of old scripts.
-
-Specify that certain ``ugly'' constructs are to be quietly accepted.
-Same as:
-
-@smallexample
--fugly-args -fugly-assign -fugly-assumed
--fugly-comma -fugly-complex -fugly-init
--fugly-logint
-@end smallexample
-
-These constructs are considered inappropriate to use in new
-or well-maintained portable Fortran code, but widely used
-in old code.
-@xref{Distensions}, for more information.
-
-@cindex -fno-ugly option
-@cindex options, -fno-ugly
-@item -fno-ugly
-@cindex ugly features
-@cindex features, ugly
-Specify that all ``ugly'' constructs are to be noisily rejected.
-Same as:
-
-@smallexample
--fno-ugly-args -fno-ugly-assign -fno-ugly-assumed
--fno-ugly-comma -fno-ugly-complex -fno-ugly-init
--fno-ugly-logint
-@end smallexample
-
-@xref{Distensions}, for more information.
-
-@cindex -ff66 option
-@cindex options, -ff66
-@item -ff66
-@cindex FORTRAN 66
-@cindex compatibility, FORTRAN 66
-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}.
-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
-existing and obsolete Fortran implementations.
-
-@cindex -ff77 option
-@cindex options, -ff77
-@item -ff77
-@cindex UNIX f77
-@cindex f2c compatibility
-@cindex compatibility, f2c
-@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.
-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
-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}.
-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}.
-
-The meaning of this option is likely to be refined as future
-versions of @code{g77} provide more compatibility with other
-existing and obsolete Fortran implementations.
-@end table
-
-@node Fortran Dialect Options
-@section Options Controlling Fortran Dialect
-@cindex dialect options
-@cindex language, dialect options
-@cindex options, dialect
-
-The following options control the dialect of Fortran
-that the compiler accepts:
-
-@table @code
-@cindex -ffree-form option
-@cindex options, -ffree-form
-@cindex -fno-fixed-form option
-@cindex options, -fno-fixed-form
-@cindex source file format
-@cindex free form
-@cindex fixed form
-@cindex Fortran 90, features
-@item -ffree-form
-@item -fno-fixed-form
-Specify that the source file is written in free form
-(introduced in Fortran 90) instead of the more-traditional fixed form.
-
-@cindex -ff90 option
-@cindex options, -ff90
-@cindex Fortran 90, features
-@item -ff90
-Allow certain Fortran-90 constructs.
-
-This option controls whether certain
-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
-current level of support for Fortran 90.)
-
-@xref{Fortran 90}, for more information.
-
-@cindex -fvxt option
-@cindex options, -fvxt
-@item -fvxt
-@cindex Fortran 90, features
-@cindex VXT extensions
-Specify the treatment of certain constructs that have different
-meanings depending on whether the code is written in
-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
-for those constructs are to be chosen.
-
-@xref{VXT Fortran}, for more information.
-
-@cindex -fdollar-ok option
-@cindex options, -fdollar-ok
-@item -fdollar-ok
-@cindex dollar sign
-@cindex symbol names
-@cindex character set
-Allow @samp{$} as a valid character in a symbol name.
-
-@cindex -fno-backslash option
-@cindex options, -fno-backslash
-@item -fno-backslash
-@cindex backslash
-@cindex character constants
-@cindex Hollerith constants
-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
-three characters, with the second one being newline.
-With @samp{-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
-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},
-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}.
-
-@cindex -fno-ugly-args option
-@cindex options, -fno-ugly-args
-@item -fno-ugly-args
-Disallow passing Hollerith and typeless constants as actual
-arguments (for example, @samp{CALL FOO(4HABCD)}).
-
-@xref{Ugly Implicit Argument Conversion}, for more information.
-
-@cindex -fugly-assign option
-@cindex options, -fugly-assign
-@item -fugly-assign
-Use the same storage for a given variable regardless of
-whether it is used to hold an assigned-statement label
-(as in @samp{ASSIGN 10 TO I}) or used to hold numeric data
-(as in @samp{I = 3}).
-
-@xref{Ugly Assigned Labels}, for more information.
-
-@cindex -fugly-assumed option
-@cindex options, -fugly-assumed
-@item -fugly-assumed
-Assume any dummy array with a final dimension specified as @samp{1}
-is really an assumed-size array, as if @samp{*} had been specified
-for the final dimension instead of @samp{1}.
-
-For example, @samp{DIMENSION X(1)} is treated as if it
-had read @samp{DIMENSION X(*)}.
-
-@xref{Ugly Assumed-Size Arrays}, for more information.
-
-@cindex -fugly-comma option
-@cindex options, -fugly-comma
-@item -fugly-comma
-In an external-procedure invocation,
-treat a trailing comma in the argument list
-as specification of a trailing null argument,
-and treat an empty argument list
-as specification of a single null argument.
-
-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.
-And @samp{F = FUNC()} is treated as @samp{F = FUNC(%VAL(0))}.
-
-The default behavior, @samp{-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)}.
-
-@xref{Ugly Null Arguments}, for more information.
-
-@cindex -fugly-complex option
-@cindex options, -fugly-complex
-@item -fugly-complex
-Do not complain about @samp{REAL(@var{expr})} or
-@samp{AIMAG(@var{expr})} when @var{expr} is a @code{COMPLEX}
-type other than @code{COMPLEX(KIND=1)}---usually
-this is used to permit @code{COMPLEX(KIND=2)}
-(@code{DOUBLE COMPLEX}) operands.
-
-The @samp{-ff90} option controls the interpretation
-of this construct.
-
-@xref{Ugly Complex Part Extraction}, for more information.
-
-@cindex -fno-ugly-init option
-@cindex options, -fno-ugly-init
-@item -fno-ugly-init
-Disallow use of Hollerith and typeless constants as initial
-values (in @code{PARAMETER} and @code{DATA} statements), and
-use of character constants to
-initialize numeric types and vice versa.
-
-For example, @samp{DATA I/'F'/, CHRVAR/65/, J/4HABCD/} is disallowed by
-@samp{-fno-ugly-init}.
-
-@xref{Ugly Conversion of Initializers}, for more information.
-
-@cindex -fugly-logint option
-@cindex options, -fugly-logint
-@item -fugly-logint
-Treat @code{INTEGER} and @code{LOGICAL} variables and
-expressions as potential stand-ins for each other.
-
-For example, automatic conversion between @code{INTEGER} and
-@code{LOGICAL} is enabled, for many contexts, via this option.
-
-@xref{Ugly Integer Conversions}, for more information.
-
-@cindex -fonetrip option
-@cindex options, -fonetrip
-@item -fonetrip
-@cindex FORTRAN 66
-@cindex @code{DO} loops, one-trip
-@cindex one-trip @code{DO} loops
-@cindex @code{DO} loops, zero-trip
-@cindex zero-trip @code{DO} loops
-@cindex compatibility, FORTRAN 66
-Executable iterative @code{DO} loops are to be executed at
-least once each time they are reached.
-
-ANSI FORTRAN 77 and more recent versions of the Fortran standard
-specify that the body of an iterative @code{DO} loop is not executed
-if the number of iterations calculated from the parameters of the
-loop is less than 1.
-(For example, @samp{DO 10 I = 1, 0}.)
-Such a loop is called a @dfn{zero-trip loop}.
-
-Prior to ANSI FORTRAN 77, many compilers implemented @code{DO} loops
-such that the body of a loop would be executed at least once, even
-if the iteration count was zero.
-Fortran code written assuming this behavior is said to require
-@dfn{one-trip loops}.
-For example, some code written to the FORTRAN 66 standard
-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
-compiled require one-trip loops.
-
-This option affects only those loops specified by the (iterative) @code{DO}
-statement and by implied-@code{DO} lists in I/O statements.
-Loops specified by implied-@code{DO} lists in @code{DATA} and
-specification (non-executable) statements are not affected.
-
-@cindex -ftypeless-boz option
-@cindex options, -ftypeless-boz
-@cindex prefix-radix constants
-@cindex constants, prefix-radix
-@cindex constants, types
-@cindex types, constants
-@item -ftypeless-boz
-Specifies that prefix-radix non-decimal constants, such as
-@samp{Z'ABCD'}, are typeless instead of @code{INTEGER(KIND=1)}.
-
-You can test for yourself whether a particular compiler treats
-the prefix form as @code{INTEGER(KIND=1)} or typeless by running the
-following program:
-
-@smallexample
-EQUIVALENCE (I, R)
-R = Z'ABCD1234'
-J = Z'ABCD1234'
-IF (J .EQ. I) PRINT *, 'Prefix form is TYPELESS'
-IF (J .NE. I) PRINT *, 'Prefix form is INTEGER'
-END
-@end smallexample
-
-Reports indicate that many compilers process this form as
-@code{INTEGER(KIND=1)}, though a few as typeless, and at least one
-based on a command-line option specifying some kind of
-compatibility.
-
-@cindex -fintrin-case-initcap option
-@cindex options, -fintrin-case-initcap
-@item -fintrin-case-initcap
-@cindex -fintrin-case-upper option
-@cindex options, -fintrin-case-upper
-@item -fintrin-case-upper
-@cindex -fintrin-case-lower option
-@cindex options, -fintrin-case-lower
-@item -fintrin-case-lower
-@cindex -fintrin-case-any option
-@cindex options, -fintrin-case-any
-@item -fintrin-case-any
-Specify expected case for intrinsic names.
-@samp{-fintrin-case-lower} is the default.
-
-@cindex -fmatch-case-initcap option
-@cindex options, -fmatch-case-initcap
-@item -fmatch-case-initcap
-@cindex -fmatch-case-upper option
-@cindex options, -fmatch-case-upper
-@item -fmatch-case-upper
-@cindex -fmatch-case-lower option
-@cindex options, -fmatch-case-lower
-@item -fmatch-case-lower
-@cindex -fmatch-case-any option
-@cindex options, -fmatch-case-any
-@item -fmatch-case-any
-Specify expected case for keywords.
-@samp{-fmatch-case-lower} is the default.
-
-@cindex -fsource-case-upper option
-@cindex options, -fsource-case-upper
-@item -fsource-case-upper
-@cindex -fsource-case-lower option
-@cindex options, -fsource-case-lower
-@item -fsource-case-lower
-@cindex -fsource-case-preserve option
-@cindex options, -fsource-case-preserve
-@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.
-
-@cindex -fsymbol-case-initcap option
-@cindex options, -fsymbol-case-initcap
-@item -fsymbol-case-initcap
-@cindex -fsymbol-case-upper option
-@cindex options, -fsymbol-case-upper
-@item -fsymbol-case-upper
-@cindex -fsymbol-case-lower option
-@cindex options, -fsymbol-case-lower
-@item -fsymbol-case-lower
-@cindex -fsymbol-case-any option
-@cindex options, -fsymbol-case-any
-@item -fsymbol-case-any
-Specify valid cases for user-defined symbol names.
-@samp{-fsymbol-case-any} is the default.
-
-@cindex -fcase-strict-upper option
-@cindex options, -fcase-strict-upper
-@item -fcase-strict-upper
-Same as @samp{-fintrin-case-upper -fmatch-case-upper -fsource-case-preserve
--fsymbol-case-upper}.
-(Requires all pertinent source to be in uppercase.)
-
-@cindex -fcase-strict-lower option
-@cindex options, -fcase-strict-lower
-@item -fcase-strict-lower
-Same as @samp{-fintrin-case-lower -fmatch-case-lower -fsource-case-preserve
--fsymbol-case-lower}.
-(Requires all pertinent source to be in lowercase.)
-
-@cindex -fcase-initcap option
-@cindex options, -fcase-initcap
-@item -fcase-initcap
-Same as @samp{-fintrin-case-initcap -fmatch-case-initcap -fsource-case-preserve
--fsymbol-case-initcap}.
-(Requires all pertinent source to be in initial capitals,
-as in @samp{Print *,SqRt(Value)}.)
-
-@cindex -fcase-upper option
-@cindex options, -fcase-upper
-@item -fcase-upper
-Same as @samp{-fintrin-case-any -fmatch-case-any -fsource-case-upper
--fsymbol-case-any}.
-(Maps all pertinent source to uppercase.)
-
-@cindex -fcase-lower option
-@cindex options, -fcase-lower
-@item -fcase-lower
-Same as @samp{-fintrin-case-any -fmatch-case-any -fsource-case-lower
--fsymbol-case-any}.
-(Maps all pertinent source to lowercase.)
-
-@cindex -fcase-preserve option
-@cindex options, -fcase-preserve
-@item -fcase-preserve
-Same as @samp{-fintrin-case-any -fmatch-case-any -fsource-case-preserve
--fsymbol-case-any}.
-(Preserves all case in user-defined symbols,
-while allowing any-case matching of intrinsics and keywords.
-For example, @samp{call Foo(i,I)} would pass two @emph{different}
-variables named @samp{i} and @samp{I} to a procedure named @samp{Foo}.)
-
-@cindex -fbadu77-intrinsics-delete option
-@cindex options, -fbadu77-intrinsics-delete
-@item -fbadu77-intrinsics-delete
-@cindex -fbadu77-intrinsics-hide option
-@cindex options, -fbadu77-intrinsics-hide
-@item -fbadu77-intrinsics-hide
-@cindex -fbadu77-intrinsics-disable option
-@cindex options, -fbadu77-intrinsics-disable
-@item -fbadu77-intrinsics-disable
-@cindex -fbadu77-intrinsics-enable option
-@cindex options, -fbadu77-intrinsics-enable
-@item -fbadu77-intrinsics-enable
-@cindex @code{badu77} intrinsics
-@cindex intrinsics, @code{badu77}
-Specify status of UNIX intrinsics having inappropriate forms.
-@samp{-fbadu77-intrinsics-enable} is the default.
-@xref{Intrinsic Groups}.
-
-@cindex -ff2c-intrinsics-delete option
-@cindex options, -ff2c-intrinsics-delete
-@item -ff2c-intrinsics-delete
-@cindex -ff2c-intrinsics-hide option
-@cindex options, -ff2c-intrinsics-hide
-@item -ff2c-intrinsics-hide
-@cindex -ff2c-intrinsics-disable option
-@cindex options, -ff2c-intrinsics-disable
-@item -ff2c-intrinsics-disable
-@cindex -ff2c-intrinsics-enable option
-@cindex options, -ff2c-intrinsics-enable
-@item -ff2c-intrinsics-enable
-@cindex @code{f2c} intrinsics
-@cindex intrinsics, @code{f2c}
-Specify status of f2c-specific intrinsics.
-@samp{-ff2c-intrinsics-enable} is the default.
-@xref{Intrinsic Groups}.
-
-@cindex -ff90-intrinsics-delete option
-@cindex options, -ff90-intrinsics-delete
-@item -ff90-intrinsics-delete
-@cindex -ff90-intrinsics-hide option
-@cindex options, -ff90-intrinsics-hide
-@item -ff90-intrinsics-hide
-@cindex -ff90-intrinsics-disable option
-@cindex options, -ff90-intrinsics-disable
-@item -ff90-intrinsics-disable
-@cindex -ff90-intrinsics-enable option
-@cindex options, -ff90-intrinsics-enable
-@item -ff90-intrinsics-enable
-@cindex Fortran 90, intrinsics
-@cindex intrinsics, Fortran 90
-Specify status of F90-specific intrinsics.
-@samp{-ff90-intrinsics-enable} is the default.
-@xref{Intrinsic Groups}.
-
-@cindex -fgnu-intrinsics-delete option
-@cindex options, -fgnu-intrinsics-delete
-@item -fgnu-intrinsics-delete
-@cindex -fgnu-intrinsics-hide option
-@cindex options, -fgnu-intrinsics-hide
-@item -fgnu-intrinsics-hide
-@cindex -fgnu-intrinsics-disable option
-@cindex options, -fgnu-intrinsics-disable
-@item -fgnu-intrinsics-disable
-@cindex -fgnu-intrinsics-enable option
-@cindex options, -fgnu-intrinsics-enable
-@item -fgnu-intrinsics-enable
-@cindex Digital Fortran features
-@cindex @code{COMPLEX} intrinsics
-@cindex intrinsics, @code{COMPLEX}
-Specify status of Digital's COMPLEX-related intrinsics.
-@samp{-fgnu-intrinsics-enable} is the default.
-@xref{Intrinsic Groups}.
-
-@cindex -fmil-intrinsics-delete option
-@cindex options, -fmil-intrinsics-delete
-@item -fmil-intrinsics-delete
-@cindex -fmil-intrinsics-hide option
-@cindex options, -fmil-intrinsics-hide
-@item -fmil-intrinsics-hide
-@cindex -fmil-intrinsics-disable option
-@cindex options, -fmil-intrinsics-disable
-@item -fmil-intrinsics-disable
-@cindex -fmil-intrinsics-enable option
-@cindex options, -fmil-intrinsics-enable
-@item -fmil-intrinsics-enable
-@cindex MIL-STD 1753
-@cindex intrinsics, MIL-STD 1753
-Specify status of MIL-STD-1753-specific intrinsics.
-@samp{-fmil-intrinsics-enable} is the default.
-@xref{Intrinsic Groups}.
-
-@cindex -funix-intrinsics-delete option
-@cindex options, -funix-intrinsics-delete
-@item -funix-intrinsics-delete
-@cindex -funix-intrinsics-hide option
-@cindex options, -funix-intrinsics-hide
-@item -funix-intrinsics-hide
-@cindex -funix-intrinsics-disable option
-@cindex options, -funix-intrinsics-disable
-@item -funix-intrinsics-disable
-@cindex -funix-intrinsics-enable option
-@cindex options, -funix-intrinsics-enable
-@item -funix-intrinsics-enable
-@cindex UNIX intrinsics
-@cindex intrinsics, UNIX
-Specify status of UNIX intrinsics.
-@samp{-funix-intrinsics-enable} is the default.
-@xref{Intrinsic Groups}.
-
-@cindex -fvxt-intrinsics-delete option
-@cindex options, -fvxt-intrinsics-delete
-@item -fvxt-intrinsics-delete
-@cindex -fvxt-intrinsics-hide option
-@cindex options, -fvxt-intrinsics-hide
-@item -fvxt-intrinsics-hide
-@cindex -fvxt-intrinsics-disable option
-@cindex options, -fvxt-intrinsics-disable
-@item -fvxt-intrinsics-disable
-@cindex -fvxt-intrinsics-enable option
-@cindex options, -fvxt-intrinsics-enable
-@item -fvxt-intrinsics-enable
-@cindex VXT intrinsics
-@cindex intrinsics, VXT
-Specify status of VXT intrinsics.
-@samp{-fvxt-intrinsics-enable} is the default.
-@xref{Intrinsic Groups}.
-
-@cindex -ffixed-line-length-@var{n} option
-@cindex options, -ffixed-line-length-@var{n}
-@item -ffixed-line-length-@var{n}
-@cindex source file format
-@cindex lines, length
-@cindex length of source lines
-@cindex fixed form
-@cindex limits, lengths of source lines
-Set column after which characters are ignored in typical fixed-form
-lines in the source file, and through which spaces are assumed (as
-if padded to that length) after the ends of short fixed-form lines.
-
-@cindex card image
-@cindex extended-source option
-Popular values for @var{n} include 72 (the
-standard and the default), 80 (card image), and 132 (corresponds
-to ``extended-source'' options in some popular compilers).
-@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}.
-
-@xref{Source Form}, for more information.
-@end table
-
-@node Warning Options
-@section Options to Request or Suppress Warnings
-@cindex options, warnings
-@cindex warnings, suppressing
-@cindex messages, warning
-@cindex suppressing warnings
-
-Warnings are diagnostic messages that report constructions which
-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
-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
-two forms, whichever is not the default.
-
-These options control the amount and kinds of warnings produced by GNU
-Fortran:
-
-@table @code
-@cindex syntax checking
-@cindex -fsyntax-only option
-@cindex options, -fsyntax-only
-@item -fsyntax-only
-Check the code for syntax errors, but don't do anything beyond that.
-
-@cindex -pedantic option
-@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
-occur in GNU Fortran source files, such as use of @samp{\e} in a
-character constant within a directive like @samp{#include}.
-
-Valid ANSI FORTRAN 77 programs should compile properly with or without
-this option.
-However, without this option, certain GNU extensions and traditional
-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
-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.
-
-@cindex -pedantic-errors option
-@cindex options, -pedantic-errors
-@item -pedantic-errors
-Like @samp{-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.
-
-@cindex -w option
-@cindex options, -w
-@item -w
-Inhibit all warning messages.
-
-@cindex -Wno-globals option
-@cindex options, -Wno-globals
-@item -Wno-globals
-@cindex global names, warning
-@cindex warnings, global names
-Inhibit warnings about use of a name as both a global name
-(a subroutine, function, or block data program unit, or a
-common block) and implicitly as the name of an intrinsic
-in a source file.
-
-Also inhibit warnings about inconsistent invocations and/or
-definitions of global procedures (function and subroutines).
-Such inconsistencies include different numbers of arguments
-and different types of arguments.
-
-@cindex -Wimplicit option
-@cindex options, -Wimplicit
-@item -Wimplicit
-@cindex implicit declaration, warning
-@cindex warnings, implicit declaration
-@cindex -u option
-@cindex /WARNINGS=DECLARATIONS switch
-@cindex IMPLICIT NONE, similar effect
-@cindex effecting IMPLICIT NONE
-Warn whenever a variable, array, or function is implicitly
-declared.
-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}.)
-
-@cindex -Wunused option
-@cindex options, -Wunused
-@item -Wunused
-@cindex unused variables
-@cindex variables, unused
-Warn whenever a variable is unused aside from its declaration.
-
-@cindex -Wuninitialized option
-@cindex options, -Wuninitialized
-@item -Wuninitialized
-@cindex uninitialized variables
-@cindex variables, uninitialized
-Warn whenever an automatic variable is used without first being initialized.
-
-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
-get these warnings.
-
-These warnings occur only for variables that are candidates for
-register allocation. Therefore, they do not occur for a variable
-@c that is declared @code{VOLATILE}, or
-whose address is taken, or whose size
-is other than 1, 2, 4 or 8 bytes. Also, they do not occur for
-arrays, even when they are in registers.
-
-Note that there might be no warning about a variable that is used only
-to compute a value that itself is never used, because such
-computations may be deleted by data-flow analysis before the warnings
-are printed.
-
-These warnings are made optional because GNU Fortran is not smart
-enough to see all the reasons why the code might be correct
-despite appearing to have an error. Here is one example of how
-this can happen:
-
-@example
-SUBROUTINE DISPAT(J)
-IF (J.EQ.1) I=1
-IF (J.EQ.2) I=4
-IF (J.EQ.3) I=5
-CALL FOO(I)
-END
-@end example
-
-@noindent
-If the value of @code{J} is always 1, 2 or 3, then @code{I} is
-always initialized, but GNU Fortran doesn't know this. Here is
-another common case:
-
-@example
-SUBROUTINE MAYBE(FLAG)
-LOGICAL FLAG
-IF (FLAG) VALUE = 9.4
-@dots{}
-IF (FLAG) PRINT *, VALUE
-END
-@end example
-
-@noindent
-This has no bug because @code{VALUE} is used only if it is set.
-
-@cindex -Wall option
-@cindex options, -Wall
-@item -Wall
-@cindex all warnings
-@cindex warnings, all
-The @samp{-Wunused} and @samp{-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}.)
-@end table
-
-The remaining @samp{-W@dots{}} options are not implied by @samp{-Wall}
-because they warn about constructions that we consider reasonable to
-use, on occasion, in clean programs.
-
-@table @code
-@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 arguments.
-@c
-@c @end itemize
-@c
-@cindex -Wsurprising option
-@cindex options, -Wsurprising
-@item -Wsurprising
-Warn about ``suspicious'' constructs that are interpreted
-by the compiler in a way that might well be surprising to
-someone reading the code.
-These differences can result in subtle, compiler-dependent
-(even machine-dependent) behavioral differences.
-The constructs warned about include:
-
-@itemize @bullet
-@item
-Expressions having two arithmetic operators in a row, such
-as @samp{X*-Y}.
-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
-this example differently than many programmers, and a few
-other compilers.
-Specifically, @code{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
-it to 0., the difference resulting from the way precedence affects
-type promotion.
-
-(The @samp{-fpedantic} option also warns about expressions
-having two arithmetic operators in a row.)
-
-@item
-Expressions with a unary minus followed by an operand and then
-a binary operator other than plus or minus.
-For example, @samp{-2**2} produces a warning, because
-the precedence is @samp{-(2**2)}, yielding -4, not
-@samp{(-2)**2}, which yields 4, and which might represent
-what a programmer expects.
-
-An example of an expression producing different results
-in a surprising way is @samp{-I*S}, where @var{I} holds
-the value @samp{-2147483648} and @var{S} holds @samp{0.5}.
-On many systems, negating @var{I} results in the same
-value, not a positive number, because it is already the
-lower bound of what an @code{INTEGER(KIND=1)} variable can hold.
-So, the expression evaluates to a positive number, while
-the ``expected'' interpretation, @samp{(-I)*S}, would
-evaluate to a negative number.
-
-Even cases such as @samp{-I*J} produce warnings,
-even though, in most configurations and situations,
-there is no computational difference between the
-results of the two interpretations---the purpose
-of this warning is to warn about differing interpretations
-and encourage a better style of coding, not to identify
-only those places where bugs might exist in the user's
-code.
-
-@cindex DO statement
-@cindex statements, DO
-@item
-@code{DO} loops with @code{DO} variables that are not
-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
-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
-are pronounced for non-integral loop control variables.)
-
-@xref{Loops}, for more information.
-@end itemize
-
-@cindex -Werror option
-@cindex options, -Werror
-@item -Werror
-Make all warnings into errors.
-
-@cindex -W option
-@cindex options, -W
-@item -W
-@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}.)
-
-``Extra warnings'' are issued for:
-
-@itemize @bullet
-@item
-@cindex unused parameters
-@cindex parameters, unused
-@cindex unused arguments
-@cindex arguments, unused
-@cindex unused dummies
-@cindex dummies, unused
-Unused parameters to a procedure (when @samp{-Wunused} also is
-specified).
-
-@item
-@cindex overflow
-Overflows involving floating-point constants (not available
-for certain configurations).
-@end itemize
-@end table
-
-@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.
-
-Some of these have no effect when compiling programs written in Fortran:
-
-@table @code
-@cindex -Wcomment option
-@cindex options, -Wcomment
-@item -Wcomment
-@cindex -Wformat option
-@cindex options, -Wformat
-@item -Wformat
-@cindex -Wparentheses option
-@cindex options, -Wparentheses
-@item -Wparentheses
-@cindex -Wswitch option
-@cindex options, -Wswitch
-@item -Wswitch
-@cindex -Wtraditional option
-@cindex options, -Wtraditional
-@item -Wtraditional
-@cindex -Wshadow option
-@cindex options, -Wshadow
-@item -Wshadow
-@cindex -Wid-clash-@var{len} option
-@cindex options, -Wid-clash-@var{len}
-@item -Wid-clash-@var{len}
-@cindex -Wlarger-than-@var{len} option
-@cindex options, -Wlarger-than-@var{len}
-@item -Wlarger-than-@var{len}
-@cindex -Wconversion option
-@cindex options, -Wconversion
-@item -Wconversion
-@cindex -Waggregate-return option
-@cindex options, -Waggregate-return
-@item -Waggregate-return
-@cindex -Wredundant-decls option
-@cindex options, -Wredundant-decls
-@item -Wredundant-decls
-@cindex unsupported warnings
-@cindex warnings, unsupported
-These options all could have some relevant meaning for
-GNU Fortran programs, but are not yet supported.
-@end table
-
-@node Debugging Options
-@section Options for Debugging Your Program or GNU Fortran
-@cindex options, debugging
-@cindex debugging information options
-
-GNU Fortran has various special options that are used for debugging
-either your program or @code{g77}.
-
-@table @code
-@cindex -g option
-@cindex options, -g
-@item -g
-Produce debugging information in the operating system's native format
-(stabs, COFF, XCOFF, or DWARF). GDB can work with this debugging
-information.
-
-@cindex common blocks
-@cindex equivalence areas
-@cindex missing debug features
-Support for this option in Fortran programs is incomplete.
-In particular, names of variables and arrays in common blocks
-or that are storage-associated via @code{EQUIVALENCE} are
-unavailable to the debugger.
-
-However, version 0.5.19 of @code{g77} does provide this information
-in a rudimentary way, as controlled by the
-@samp{-fdebug-kludge} option.
-
-@xref{Code Gen Options,,Options for Code Generation Conventions},
-for more information.
-@end table
-
-@xref{Debugging Options,,Options for Debugging Your Program or GNU CC,
-gcc,Using and Porting GNU CC}, for more information on debugging options.
-
-@node Optimize Options
-@section Options That Control Optimization
-@cindex optimize options
-@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
-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.
-
-The following flags have particular applicability when
-compiling Fortran programs:
-
-@table @code
-@cindex -malign-double option
-@cindex options, -malign-double
-@item -malign-double
-(Intel x86 architecture only.)
-
-Noticeably improves performance of @code{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
-686 implementations
-of the i386 architecture execute programs faster when
-@code{REAL(KIND=2)} (@code{DOUBLE PRECISION}) data are
-aligned on 64-bit boundaries
-in memory.
-
-This option can, at least, make benchmark results more consistent
-across various system configurations, versions of the program,
-and data sets.
-
-@emph{Note:} The warning in the @code{gcc} documentation about
-this option does not apply, generally speaking, to Fortran
-code compiled by @code{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}.
-
-@cindex -ffloat-store option
-@cindex options, -ffloat-store
-@item -ffloat-store
-@cindex IEEE 754 conformance
-@cindex conformance, IEEE 754
-@cindex floating-point, precision
-Might help a Fortran program that depends on exact IEEE conformance on
-some machines, but might slow down a program that doesn't.
-
-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}
-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
-only partially effective. `Excess precision' is avoided in code like:
-@smallexample
-a = b + c
-d = a * e
-@end smallexample
-but not in code like:
-@smallexample
- d = (b + c) * e
-@end smallexample
-
-For another, potentially better, way of controlling the precision,
-see @ref{Floating-point precision}.
-
-@cindex -fforce-mem option
-@cindex options, -fforce-mem
-@item -fforce-mem
-@cindex -fforce-addr option
-@cindex options, -fforce-addr
-@item -fforce-addr
-@cindex loops, speeding up
-@cindex speed, of loops
-Might improve optimization of loops.
-
-@cindex -fno-inline option
-@cindex options, -fno-inline
-@item -fno-inline
-@cindex in-line code
-@cindex compilation, in-line
-@c DL: Only relevant for -O3?
-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).
-Note that if you are not optimizing, no functions can be expanded inline.
-
-@cindex -ffast-math option
-@cindex options, -ffast-math
-@item -ffast-math
-@cindex IEEE 754 conformance
-@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.
-
-@cindex -fstrength-reduce option
-@cindex options, -fstrength-reduce
-@item -fstrength-reduce
-@cindex loops, speeding up
-@cindex speed, of loops
-@c DL: normally defaulted?
-Might make some loops run faster.
-
-@cindex -frerun-cse-after-loop option
-@cindex options, -frerun-cse-after-loop
-@item -frerun-cse-after-loop
-@cindex -fexpensive-optimizations option
-@cindex options, -fexpensive-optimizations
-@c DL: This is -O2?
-@item -fexpensive-optimizations
-@cindex -fdelayed-branch option
-@cindex options, -fdelayed-branch
-@item -fdelayed-branch
-@cindex -fschedule-insns option
-@cindex options, -fschedule-insns
-@item -fschedule-insns
-@cindex -fschedule-insns2 option
-@cindex options, -fschedule-insns2
-@item -fschedule-insns2
-@cindex -fcaller-saves option
-@cindex options, -fcaller-saves
-@item -fcaller-saves
-Might improve performance on some code.
-
-@cindex -funroll-loops option
-@cindex options, -funroll-loops
-@item -funroll-loops
-@cindex loops, unrolling
-@cindex unrolling loops
-@cindex loops, optimizing
-@cindex indexed (iterative) @code{DO}
-@cindex iterative @code{DO}
-@c DL: fixme: Craig doesn't like `indexed' but f95 doesn't seem to
-@c provide a suitable term
-@c CB: I've decided on `iterative', for the time being, and changed
-@c my previous, rather bizarre, use of `imperative' to that
-@c (though `precomputed-trip' would be a more precise adjective)
-Typically improves performance on code using iterative @code{DO} loops by
-unrolling them and is probably generally appropriate for Fortran, though
-it is not turned on at any optimization level.
-Note that outer loop unrolling isn't done specifically; decisions about
-whether to unroll a loop are made on the basis of its instruction count.
-
-@c DL: Fixme: This should obviously go somewhere else...
-Also, no `loop discovery'@footnote{@dfn{loop discovery} refers to the
-process by which a compiler, or indeed any reader of a program,
-determines which portions of the program are more likely to be executed
-repeatedly as it is being run. Such discovery typically is done early
-when compiling using optimization techniques, so the ``discovered''
-loops get more attention---and more run-time resources, such as
-registers---from the compiler. It is easy to ``discover'' loops that are
-constructed out of looping constructs in the language
-(such as Fortran's @code{DO}). For some programs, ``discovering'' loops
-constructed out of lower-level constructs (such as @code{IF} and
-@code{GOTO}) can lead to generation of more optimal code
-than otherwise.} is done, so only loops written with @code{DO}
-benefit from loop optimizations, including---but not limited
-to---unrolling. Loops written with @code{IF} and @code{GOTO} are not
-currently recognized as such. This option unrolls only iterative
-@code{DO} loops, not @code{DO WHILE} loops.
-
-@cindex -funroll-all-loops option
-@cindex options, -funroll-all-loops
-@cindex DO WHILE
-@item -funroll-all-loops
-@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}
-but possibly slower.
-
-@item -fno-move-all-movables
-@cindex -fno-move-all-movables option
-@cindex options, -fno-move-all-movables
-@item -fno-reduce-all-givs
-@cindex -fno-reduce-all-givs option
-@cindex options, -fno-reduce-all-givs
-@item -fno-rerun-loop-opt
-@cindex -fno-rerun-loop-opt option
-@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.
-
-Each of these might improve performance on some code.
-
-Analysis of Fortran code optimization and the resulting
-optimizations triggered by the above options were
-contributed by Toon Moene (@email{toon@@moene.indiv.nluug.nl}).
-
-These three options are intended to be removed someday, once
-they have helped determine the efficacy of various
-approaches to improving the performance of Fortran code.
-
-Please let us know how use of these options affects
-the performance of your production 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.
-@end table
-
-@xref{Optimize Options,,Options That Control Optimization,
-gcc,Using and Porting GNU CC}, for more information on options
-to optimize the generated machine code.
-
-@node Preprocessor Options
-@section Options Controlling the Preprocessor
-@cindex preprocessor options
-@cindex options, preprocessor
-@cindex cpp program
-@cindex programs, cpp
-
-These options control the C preprocessor, which is run on each C source
-file before actual compilation.
-
-@xref{Preprocessor Options,,Options Controlling the Preprocessor,
-gcc,Using and Porting GNU CC}, for information on C preprocessor options.
-
-@cindex INCLUDE directive
-@cindex directive, INCLUDE
-Some of these options also affect how @code{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.
-
-However, the @code{INCLUDE} directive does not apply
-preprocessing to the contents of the included file itself.
-
-Therefore, any file that contains preprocessor directives
-(such as @code{#include}, @code{#define}, and @code{#if})
-must be included via the @code{#include} directive, not
-via the @code{INCLUDE} directive.
-Therefore, any file containing preprocessor directives,
-if included, is necessarily included by a file that itself
-contains preprocessor directives.
-
-@node Directory Options
-@section Options for Directory Search
-@cindex directory, options
-@cindex options, directory search
-@cindex search path
-
-These options affect how the @code{cpp} preprocessor searches
-for files specified via the @code{#include} directive.
-Therefore, when compiling Fortran programs, they are meaningful
-when the preprocessor is used.
-
-@cindex INCLUDE directive
-@cindex directive, INCLUDE
-Some of these options also affect how @code{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
-@cindex -I- option
-@cindex options, -I-
-@item -I-
-@cindex -Idir option
-@cindex options, -Idir
-@item -I@var{dir}
-@cindex directory, search paths for inclusion
-@cindex inclusion, directory search paths for
-@cindex search paths, for included files
-@cindex paths, search
-These affect interpretation of the @code{INCLUDE} directive
-(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
-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
-@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.
-@end table
-
-@node Code Gen Options
-@section Options for Code Generation Conventions
-@cindex code generation, conventions
-@cindex options, code generation
-@cindex run-time, options
-
-These machine-independent options control the interface conventions
-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
-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
-it.
-
-@table @code
-@cindex -fno-automatic option
-@cindex options, -fno-automatic
-@item -fno-automatic
-@cindex SAVE statement
-@cindex statements, SAVE
-Treat each program unit as if the @code{SAVE} statement was specified
-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}.)
-
-@cindex -finit-local-zero option
-@cindex options, -finit-local-zero
-@item -finit-local-zero
-@cindex DATA statement
-@cindex statements, DATA
-@cindex initialization, of local variables
-@cindex variables, initialization of
-@cindex uninitialized variables
-@cindex variables, uninitialized
-Specify that variables and arrays that are local to a program unit
-(not in a common block and not passed as an argument) are to be initialized
-to binary zeros.
-
-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}.
-
-@cindex -fno-f2c option
-@cindex options, -fno-f2c
-@item -fno-f2c
-@cindex @code{f2c} compatibility
-@cindex compatibility, @code{f2c}
-Do not generate code designed to be compatible with code generated
-by @code{f2c}; use the GNU calling conventions instead.
-
-The @code{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
-to where to store the return value.
-Under the GNU calling conventions, such functions simply return
-their results as they would in GNU C---@code{REAL(KIND=1)} functions
-return the C type @code{float}, and @code{COMPLEX} functions
-return the GNU C type @code{complex} (or its @code{struct}
-equivalent).
-
-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
-intrinsics implemented by routines in this library as actual
-arguments when @samp{-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
-offer routines that provide GNU-callable versions of the
-routines that implement the @code{f2c}-callable intrinsics
-that may be passed as actual arguments, so that
-valid programs need not be rejected when @samp{-fno-f2c}
-is used.)
-
-@strong{Caution:} If @samp{-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.
-
-@c seems kinda dumb to tell people about an option they can't use -- jcb
-@c then again, we want users building future-compatible libraries with it.
-@cindex -ff2c-library option
-@cindex options, -ff2c-library
-@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}.
-
-Currently it is not
-valid to specify @samp{-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
-generating code for an incompatible library.
-
-@cindex -fno-underscoring option
-@cindex options, -fno-underscoring
-@item -fno-underscoring
-@cindex underscore
-@cindex symbol names, underscores
-@cindex transforming symbol names
-@cindex symbol names, transforming
-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
-to names with underscores and one underscore to external names with
-no underscores. (@code{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
-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
-same transformations.
-
-Use of @samp{-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
-external functions while @samp{my_var} and @samp{lvar} are local variables,
-a statement like
-
-@smallexample
-I = J() + MAX_COUNT (MY_VAR, LVAR)
-@end smallexample
-
-@noindent
-is implemented as something akin to:
-
-@smallexample
-i = j_() + max_count__(&my_var__, &lvar);
-@end smallexample
-
-With @samp{-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
-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 some other language for that same name.
-That is, getting code produced by @code{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
-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
-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
-interfaces.
-
-@cindex -fno-second-underscore option
-@cindex options, -fno-second-underscore
-@item -fno-second-underscore
-@cindex underscore
-@cindex symbol names, underscores
-@cindex transforming symbol names
-@cindex symbol names, transforming
-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
-in effect.
-
-Otherwise, with this option, an external name such as @samp{MAX_COUNT}
-is implemented as a reference to the link-time external symbol
-@samp{max_count_}, instead of @samp{max_count__}.
-
-@cindex -fno-ident option
-@cindex options, -fno-ident
-@item -fno-ident
-Ignore the @samp{#ident} directive.
-
-@cindex -fzeros option
-@cindex options, -fzeros
-@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
-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
-are produced.
-
-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
-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
-(and its negative form, the default) or interpret it somewhat
-differently.
-The interpretation changes will affect only non-standard
-programs; standard-conforming programs should not be affected.
-
-@cindex -fdebug-kludge option
-@cindex options, -fdebug-kludge
-@item -fdebug-kludge
-Emit information on @code{COMMON} and @code{EQUIVALENCE} members
-that might help users of debuggers work around lack of proper debugging
-information on such members.
-
-As of version 0.5.19, @code{g77} offers this option to emit
-information on members of aggregate areas to help users while debugging.
-This information consists of establishing the type and contents of each
-such member so that, when a debugger is asked to print the contents,
-the printed information provides rudimentary debugging information.
-This information identifies the name of the aggregate area (either the
-@code{COMMON} block name, or the @code{g77}-assigned name for the
-@code{EQUIVALENCE} name) and the offset, in bytes, of the member from
-the beginning of the area.
-
-Using @code{gdb}, this information is not coherently displayed in the Fortran
-language mode, so temporarily switching to the C language mode to display the
-information is suggested.
-Use @samp{set language c} and @samp{set language fortran} to accomplish this.
-
-For example:
-
-@smallexample
- COMMON /X/A,B
- EQUIVALENCE (C,D)
- CHARACTER XX*50
- EQUIVALENCE (I,XX(20:20))
- END
-
-GDB is free software and you are welcome to distribute copies of it
- under certain conditions; type "show copying" to see the conditions.
-There is absolutely no warranty for GDB; type "show warranty" for details.
-GDB 4.16 (lm-gnits-dwim), Copyright 1996 Free Software Foundation, Inc...
-(gdb) b MAIN__
-Breakpoint 1 at 0t1200000201120112: file cd.f, line 5.
-(gdb) r
-Starting program: /home/user/a.out
-
-Breakpoint 1, MAIN__ () at cd.f:5
-Current language: auto; currently fortran
-(gdb) set language c
-Warning: the current language does not match this frame.
-(gdb) p a
-$2 = "At (COMMON) `x_' plus 0 bytes"
-(gdb) p b
-$3 = "At (COMMON) `x_' plus 4 bytes"
-(gdb) p c
-$4 = "At (EQUIVALENCE) `__g77_equiv_c' plus 0 bytes"
-(gdb) p d
-$5 = "At (EQUIVALENCE) `__g77_equiv_c' plus 0 bytes"
-(gdb) p i
-$6 = "At (EQUIVALENCE) `__g77_equiv_xx' plus 20 bytes"
-(gdb) p xx
-$7 = "At (EQUIVALENCE) `__g77_equiv_xx' plus 1 bytes"
-(gdb) set language fortran
-(gdb)
-@end smallexample
+@cindex cc1plus 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},
+@command{gcc} would use the C++ compiler (named @code{cc1plus}).
-@noindent
-Use @samp{-fdebug-kludge} to generate this information,
-which might make some programs noticeably larger.
-
-@emph{Caution:} Future versions of @code{g77} might disregard this option
-(and its negative form).
-Current plans call for this to happen when published versions of @code{g77}
-and @code{gdb} exist that provide proper access to debugging information on
-@code{COMMON} and @code{EQUIVALENCE} members.
-
-@cindex -femulate-complex option
-@cindex options, -femulate-complex
-@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
-@code{complex} arithmetic.
-
-(@code{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,
-or experience compiler crashes,
-that might result from @code{g77} using the @code{COMPLEX} support
-in the @code{gcc} back end.
-If using that option fixes the bugs or crashes you are seeing,
-that indicates a likely @code{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}.
-
-@emph{Caution:} Future versions of @code{g77} might ignore both forms
-of this option.
+@cindex @code{f771}, program
+@cindex programs, @code{f771}
+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 -falias-check option
-@cindex options, -falias-check
-@cindex -fargument-alias option
-@cindex options, -fargument-alias
-@cindex -fargument-noalias option
-@cindex options, -fargument-noalias
-@cindex -fno-argument-noalias-global option
-@cindex options, -fno-argument-noalias-global
-@item -falias-check
-@item -fargument-alias
-@item -fargument-noalias
-@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.
-
-These options specify to what degree aliasing
-(overlap)
-is permitted between
-arguments (passed as pointers) and @code{COMMON} (external, or
-public) storage.
-
-The default for Fortran code, as mandated by the FORTRAN 77 and
-Fortran 90 standards, is @samp{-fargument-noalias-global}.
-The default for code written in the C language family is
-@samp{-fargument-alias}.
-
-Note that, on some systems, compiling with @samp{-fforce-addr} in
-effect can produce more optimal code when the default aliasing
-options are in effect (and when optimization is enabled).
+@cindex @command{gcc}, not recognizing Fortran source
+@cindex unrecognized file format
+@cindex file format not recognized
+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}).
+@command{g77} can still compile and link programs and
+source files written in other languages, just like @command{gcc}.
-@xref{Aliasing Assumed To Work}, for detailed information on the implications
-of compiling Fortran code that depends on the ability to alias dummy
-arguments.
+@cindex printing version information
+@cindex version information, printing
+The command @samp{g77 -v} is a quick
+way to display lots of version information for the various programs
+used to compile a typical preprocessed Fortran source file---this
+produces much more output than @samp{gcc -v} currently does.
+(If it produces an error message near the end of the output---diagnostics
+from the linker, usually @command{ld}---you might
+have an out-of-date @code{libf2c} that improperly handles
+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 @command{gcc}
+with which that version of @command{g77} was built.
+
+@cindex libf2c library
+@cindex libraries, libf2c
+The @code{libf2c} library is distributed with GNU Fortran for
+the convenience of its users, but is not part of GNU Fortran.
+It contains the procedures
+needed by Fortran programs while they are running.
-@cindex -fno-globals option
-@cindex options, -fno-globals
-@item -fno-globals
-@cindex global names, warning
-@cindex warnings, global names
@cindex in-line code
-@cindex compilation, in-line
-Disable diagnostics about inter-procedural
-analysis problems, such as disagreements about the
-type of a function or a procedure's argument,
-that might cause a compiler crash when attempting
-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,
-in which case no relevant diagnostics are produced.)
-
-Further, this option disables such inlining, to
-avoid compiler crashes resulting from incorrect
-code that would otherwise be diagnosed.
-
-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.
-
-Use of this option therefore has the effect of
-instructing @code{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
-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 crash the compiler as (fatal) errors,
-and warns about similar disagreements
-that are currently believed to not
-likely to result in the compiler later crashing
-or producing incorrect code.
-
-@cindex -fflatten-arrays option
-@item -fflatten-arrays
-@cindex array performance
-@cindex arrays, flattening
-Use back end's C-like constructs
-(pointer plus offset)
-instead of its @code{ARRAY_REF} construct
-to handle all array references.
-
-@emph{Note:} This option is not supported.
-It is intended for use only by @code{g77} developers,
-to evaluate code-generation issues.
-It might be removed at any time.
-
-@cindex -fbounds-check option
-@cindex -ffortran-bounds-check option
-@item -fbounds-check
-@itemx -ffortran-bounds-check
-@cindex bounds checking
-@cindex range checking
-@cindex array bounds checking
-@cindex subscript checking
-@cindex substring checking
-@cindex checking subscripts
-@cindex checking substrings
-Enable generation of run-time checks for array subscripts
-and substring start and end points
-against the (locally) declared minimum and maximum values.
-
-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
-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,
-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.
-
-Use the new @samp{-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}
-with somewhat differently-formatted information.
-Here's a sample diagnostic:
+@cindex code, in-line
+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.
-@smallexample
-Subscript out of range on file line 4, procedure rnge.f/bf.
-Attempt to access the -6-th element of variable b[subscript-2-of-2].
-Aborted
-@end smallexample
+Instead, operations like trigonometric
+functions are compiled by the @code{f771} compiler
+(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 @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 @command{f2c},
+a free Fortran-to-C converter distributed by Bellcore (AT&T),
+plus @code{libU77}, provided by Dave Love,
+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.
-The above message indicates that the offending source line is
-line 4 of the file @file{rnge.f},
-within the program unit (or statement function) named @samp{bf}.
-The offended array is named @samp{b}.
-The offended array dimension is the second for a two-dimensional array,
-and the offending, computed subscript expression was @samp{-6}.
+@cindex GNU Back End (GBE)
+@cindex GBE
+@cindex @command{gcc}, back end
+@cindex back end, gcc
+@cindex code generator
+One chunk is the so-called @dfn{GNU Back End}, or GBE,
+which knows how to generate fast code for a wide variety of processors.
+The same GBE is used by the C, C++, and Fortran compiler programs @code{cc1},
+@code{cc1plus}, and @code{f771}, plus others.
+Often the GBE is referred to as the ``gcc back end'' or
+even just ``gcc''---in this manual, the term GBE is used
+whenever the distinction is important.
-For a @code{CHARACTER} substring reference, the second line has
-this appearance:
+@cindex GNU Fortran Front End (FFE)
+@cindex FFE
+@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
+do, and then communicate that knowledge to the GBE for actual compilation
+of those programs.
+This chunk is called the @dfn{Fortran Front End} (FFE).
+The @code{cc1} and @code{cc1plus} programs have their own front ends,
+for the C and C++ languages, respectively.
+These fronts ends are responsible for diagnosing
+incorrect usage of their respective languages by the
+programs the process, and are responsible for most of
+the warnings about questionable constructs as well.
+(The GBE handles producing some warnings, like those
+concerning possible references to undefined variables.)
-@smallexample
-Attempt to access the 11-th element of variable a[start-substring].
-@end smallexample
+Because so much is shared among the compilers for various languages,
+much of the behavior and many of the user-selectable options for these
+compilers are similar.
+For example, diagnostics (error messages and
+warnings) are similar in appearance; command-line
+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).
-This indicates that the offended @code{CHARACTER} variable or array
-is named @samp{a},
-the offended substring position is the starting (leftmost) position,
-and the offending substring expression is @samp{11}.
+@node G77 and GCC
+@chapter Compile Fortran, C, or Other Programs
+@cindex compiling programs
+@cindex programs, compiling
-(Though the verbage of @code{s_rnge} is not ideal
-for the purpose of the @code{g77} compiler,
-the above information should provide adequate diagnostic abilities
-to it users.)
-@end table
+@cindex @command{gcc}, command
+@cindex commands, @command{gcc}
+A GNU Fortran installation includes a modified version of the @command{gcc}
+command.
-@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.
+In a non-Fortran installation, @command{gcc} recognizes C, C++,
+and Objective-C source files.
-Some of these do @emph{not} work when compiling programs written in Fortran:
+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.
-@table @code
-@cindex -fpcc-struct-return option
-@cindex options, -fpcc-struct-return
-@item -fpcc-struct-return
-@cindex -freg-struct-return option
-@cindex options, -freg-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
-same option.
-
-@cindex -fshort-double option
-@cindex options, -fshort-double
-@item -fshort-double
-This probably either has no effect on Fortran programs, or
-makes them act loopy.
-
-@cindex -fno-common option
-@cindex options, -fno-common
-@item -fno-common
-Do not use this when compiling Fortran programs,
-or there will be Trouble.
-
-@cindex -fpack-struct option
-@cindex options, -fpack-struct
-@item -fpack-struct
-This probably will break any calls to the @code{libg2c} library,
-at the very least, even if it is built with the same option.
-@end table
+@xref{G++ and GCC,,Compile C; C++; Objective-C; Ada; Fortran;
+or Java,gcc,Using the GNU Compiler Collection (GCC)},
+for information on the way different languages are handled
+by the GNU CC compiler (@command{gcc}).
-@node Environment Variables
-@section Environment Variables Affecting GNU Fortran
-@cindex environment variables
+@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 @command{gcc} command.
-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}.
+@cindex -v option
+@cindex @command{g77} options, -v
+@cindex options, -v
+Use the @option{-v} option with @command{g77}
+to see what is going on---the first line of output is the invocation
+of the @command{gcc} command.
-@xref{Environment Variables,,Environment Variables Affecting GNU CC,
-gcc,Using and Porting GNU CC}, for information on environment
-variables.
+@include invoke.texi
@include news.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 @command{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.
@itemize @bullet
@item
Serving as a mostly-upwards-compatible language from the
-de facto UNIX Fortran dialect as supported by @code{f77}.
+de facto UNIX Fortran dialect as supported by @command{f77}.
@item
Offering new, well-designed language features.
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
A newline in the file is the character that represents the end of
a line of text to the underlying system.
For example, on ASCII-based systems, a newline is the @key{NL}
-character, which has ASCII value 12 (decimal).
+character, which has ASCII value 10 (decimal).
@item
Each newline in the file serves to end the line of text that precedes
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
(@pxref{C Preprocessor Output,,, cpp, The C Preprocessor})
are recognized by the compiler even
when the preprocessor isn't run on the input (as it is when compiling
-@samp{.F} files). (Note the distinction between these @code{cpp}
+@samp{.F} files). (Note the distinction between these @command{cpp}
@code{#} @emph{output} directives and @code{#line} @emph{input}
directives.)
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
@itemize @bullet
@item
Digital Semiconductor (``DEC'') Alpha OSF/1, HP-UX 10.0.1, AIX 3.2.5
-@code{f77} compilers all implement @samp{Interp 1}.
+@command{f77} compilers all implement @samp{Interp 1}.
@item
-IRIX 5.3 @code{f77} compiler implements @samp{Interp 2}.
+IRIX 5.3 @command{f77} compiler implements @samp{Interp 2}.
@item
Solaris 2.5, SunOS 4.1.3, DECstation ULTRIX 4.3,
-and IRIX 6.1 @code{f77} compilers all implement @samp{Interp 3}.
+and IRIX 6.1 @command{f77} compilers all implement @samp{Interp 3}.
@end itemize
If you get different results than the above for the stated
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 @command{f77}/@command{f2c} Intrinsics
The bit-manipulation intrinsics supported by traditional
-@code{f77} and by @code{f2c} are available in the GNU Fortran language.
+@command{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}.
@ifinfo
(Note that the empty lines appearing in the menu below
are not intentional---they result from a bug in the
-GNU @code{makeinfo} program@dots{}a program that, if it
+GNU @command{makeinfo} program@dots{}a program that, if it
did not exist, would leave this document in far worse shape!)
@end ifinfo
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
-definition along with more
-flexibility offered by command-line options is likely to be offered
-in version 0.6.
+(@command{f2c}, Digital (``DEC'') Fortran, and so on).
-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
+for the UNIX @command{expand} command) before doing any other processing, other
than (currently) noting whether a tab was found on a line and using this
information to decide how to interpret the length of the line and continued
constants.
-Note that this default behavior probably will change for version 0.6,
-when it will presumably be available via a command-line option.
-The default as of version 0.6 is planned to be a ``pure visual''
-model, where tabs are immediately
-converted to spaces and otherwise have no effect, so the way a typical
-user sees source lines produces a consistent result no matter how the
-spacing in those source lines is actually implemented via tabs, spaces,
-and trailing tabs/spaces before newline.
-Command-line options are likely to be added to specify whether all or
-just-tabbed lines are to be extended to 132 or full input-line length,
-and perhaps even an option will be added to specify the truncated-line
-behavior to which some Digital compilers default (and which affects
-the way continued character/Hollerith constants are interpreted).
-
@node Short Lines
@subsection Short Lines
@cindex short source lines
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 @command{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 @command{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),
+driver program (or @command{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}.
+@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 @command{ftnchek} tool from @uref{ftp://ftp.netlib.org/fortran}
or @uref{ftp://ftp.dsm.fordham.edu} is
probably better for this purpose.}
If the Fortran code containing any
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}.
-@include g77install.texi
-
@node Debugging and Interfacing
@chapter Debugging and Interfacing
@cindex debugging
@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
The standard way to get around this problem is to set a break
point (a one-time, or temporary, break point will do) at
the entrance to @code{MAIN__}, and then run the program.
-A convenient way to do so is to add the @code{gdb} command
+A convenient way to do so is to add the @command{gdb} command
@example
tbreak MAIN__
@noindent
to the file @file{.gdbinit} in the directory in which you're debugging
-(using @code{gdb}).
+(using @command{gdb}).
After doing this, the debugger will see the current execution
point of the program as at the beginning of the main program
@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}.
-
-Currently, @code{g77} does not emit ``true'' debugging information for
-members of a @code{COMMON} area, due to an apparent bug in the GBE.
-
-(As of Version 0.5.19, @code{g77} emits debugging information for such
-members in the form of a constant string specifying the base name of
-the aggregate area and the offset of the member in bytes from the start
-of the area.
-Use the @samp{-fdebug-kludge} option to enable this behavior.
-In @code{gdb}, use @samp{set language c} before printing the value
-of the member, then @samp{set language fortran} to restore the default
-language, since @code{gdb} doesn't provide a way to print a readable
-version of a character string in Fortran language mode.
-
-This kludge will be removed in a future version of @code{g77} that,
-in conjunction with a contemporary version of @code{gdb},
-properly supports Fortran-language debugging, including access
-to members of @code{COMMON} areas.)
-
-@xref{Code Gen Options,,Options for Code Generation Conventions},
-for information on the @samp{-fdebug-kludge} option.
-
-Moreover, @code{g77} currently implements a @code{COMMON} area such that its
-type is an array of the C @code{char} data type.
-
-So, when debugging, you must know the offset into a @code{COMMON} area
-for a particular item in that area, and you have to take into
-account the appropriate multiplier for the respective sizes
-of the types (as declared in your code) for the items preceding
-the item in question as compared to the size of the @code{char} type.
-
-For example, using default implicit typing, the statement
-
-@example
-COMMON I(15), R(20), T
-@end example
-
-@noindent
-results in a public 144-byte @code{char} array named @samp{_BLNK__}
-with @samp{I} placed at @samp{_BLNK__[0]}, @samp{R} at @samp{_BLNK__[60]},
-and @samp{T} at @samp{_BLNK__[140]}.
-(This is assuming that the target machine for
-the compilation has 4-byte @code{INTEGER(KIND=1)} and @code{REAL(KIND=1)}
-types.)
+@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.
-Currently, @code{g77} does not emit ``true'' debugging information for
-members in a local @code{EQUIVALENCE} area, due to an apparent bug in the GBE.
-
-(As of Version 0.5.19, @code{g77} does emit debugging information for such
-members in the form of a constant string specifying the base name of
-the aggregate area and the offset of the member in bytes from the start
-of the area.
-Use the @samp{-fdebug-kludge} option to enable this behavior.
-In @code{gdb}, use @samp{set language c} before printing the value
-of the member, then @samp{set language fortran} to restore the default
-language, since @code{gdb} doesn't provide a way to print a readable
-version of a character string in Fortran language mode.
-
-This kludge will be removed in a future version of @code{g77} that,
-in conjunction with a contemporary version of @code{gdb},
-properly supports Fortran-language debugging, including access
-to members of @code{EQUIVALENCE} areas.)
-
-@xref{Code Gen Options,,Options for Code Generation Conventions},
-for information on the @samp{-fdebug-kludge} option.
-
-Moreover, @code{g77} implements a local @code{EQUIVALENCE} area such that its
-type is an array of the C @code{char} data type.
-
-The name @code{g77} gives this array of @code{char} type is @samp{__g77_equiv_@var{x}},
-where @var{x} is the name of the item that is placed at the beginning (offset 0)
-of this array.
-If more than one such item is placed at the beginning, @var{x} is
-the name that sorts to the top in an alphabetical sort of the list of
-such items.
-
-When debugging, you must therefore access members of @code{EQUIVALENCE}
-areas by specifying the appropriate @samp{__g77_equiv_@var{x}}
-array section with the appropriate offset.
-See the explanation of debugging @code{COMMON} blocks
-for info applicable to debugging local @code{EQUIVALENCE} areas.
-
-(@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
these @code{struct} types as being substitutes for Fortran
complex.
As a result, the Fortran language modes of debuggers such as
-@code{gdb} see these types as C @code{struct} types, which
+@command{gdb} see these types as C @code{struct} types, which
they might or might not support.
Until this is fixed, switch to C language mode to work with
entities of @code{COMPLEX} type and then switch back to Fortran language
mode afterward.
-(In @code{gdb}, this is accomplished via @samp{set lang c} and
+(In @command{gdb}, this is accomplished via @samp{set lang c} and
either @samp{set lang fortran} or @samp{set lang auto}.)
@node Arrays
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}; @command{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, which control the assumptions regarding aliasing
+These options control the assumptions regarding aliasing
(overlapping) of writes and reads to main memory (core) made
-by the @code{gcc} back end,
-might well be added back (in some form) in a future version
-of @code{gcc}.
-
-However, these options @emph{are} supported by @code{egcs}.
+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.)
-@xref{Always Flush Output}, for information on how to modify
-the @code{g77} source tree so that a version of @code{libg2c}
-can be built and installed with the @code{ALWAYS_FLUSH} macro defined.
+Some Fortran programs require output
+(writes) to be flushed to the operating system (under UNIX,
+via the @code{fflush()} library call) so that errors,
+such as disk full, are immediately flagged via the relevant
+@code{ERR=} and @code{IOSTAT=} mechanism, instead of such
+errors being flagged later as subsequent writes occur, forcing
+the previously written data to disk, or when the file is
+closed.
+
+Essentially, the difference can be viewed as synchronous error
+reporting (immediate flagging of errors during writes) versus
+asynchronous, or, more precisely, buffered error reporting
+(detection of errors might be delayed).
+
+@code{libg2c} supports flagging write errors immediately when
+it is built with the @code{ALWAYS_FLUSH} macro defined.
+This results in a @code{libg2c} that runs slower, sometimes
+quite a bit slower, under certain circumstances---for example,
+accessing files via the networked file system NFS---but the
+effect can be more reliable, robust file I/O.
+
+If you know that Fortran programs requiring this level of precision
+of error reporting are to be compiled using the
+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 @command{g77} source tree:
+
+@example
+/* #define ALWAYS_FLUSH */
+@end example
+
+Remove the leading @samp{/*@w{ }},
+so the line begins with @samp{#define},
+and the trailing @samp{@w{ }*/}.
+
+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.
-Otherwise, see @ref{Larger File Unit Numbers}, for information on how
-to change @code{MXUNIT} in @code{libg2c} so you can build and
-install a new version of @code{libg2c} that supports the larger
-unit numbers you need.
+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
+a run-time crash in @code{libf2c}, because the unit number,
+100, is out of range.
-@emph{Note:} While @code{libg2c} places a limit on the range
-of Fortran file-unit numbers, the underlying library and operating
-system might impose different kinds of limits.
-For example, some systems limit the number of files simultaneously
-open by a running program.
-Information on how to increase these limits should be found
+If you know that Fortran programs at your installation require
+the use of unit numbers higher than 99, you can change the
+value of the @code{MXUNIT} macro, which represents the maximum unit
+number, to an appropriately higher value.
+
+To do this, edit the file @file{@value{path-libf2c}/libI77/fio.h} in your
+@command{g77} source tree, changing the following line:
+
+@example
+#define MXUNIT 100
+@end example
+
+Change the line so that the value of @code{MXUNIT} is defined to be
+at least one @emph{greater} than the maximum unit number used by
+the Fortran programs on your system.
+
+(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 @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.
+That is, the macro might allow a program to do @samp{WRITE (UNIT=100)},
+but the library and operating system underlying @code{libf2c} might
+disallow it if many other files have already been opened (via @code{OPEN} or
+implicitly via @code{READ}, @code{WRITE}, and so on).
+Information on how to increase these other limits should be found
in your system's documentation.
@node Floating-point precision
@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}).
-The control word could be set to double precision by
-replacing the @code{__setfpucw} call with one like this:
+The control word could be set to double precision by some code like this
+one:
@smallexample
- __setfpucw ((_FPU_DEFAULT & ~_FPU_EXTENDED) | _FPU_DOUBLE);
+#include <fpu_control.h>
+@{
+ fpu_control_t cw = (_FPU_DEFAULT & ~_FPU_EXTENDED) | _FPU_DOUBLE;
+ _FPU_SETCW(cw);
+@}
@end smallexample
(It is not clear whether this has any effect on the operation of the GNU
maths library, but we have no evidence of it causing trouble.)
Some targets (such as the Alpha) may need special options for full IEEE
conformance.
-@xref{Submodel Options,,Hardware Models and Configurations,gcc,Using and Porting GNU CC}.
+@xref{Submodel Options,,Hardware Models and Configurations,gcc,Using
+the GNU Compiler Collection (GCC)}.
@node Inconsistent Calling Sequences
@subsection Inconsistent Calling Sequences
@cindex x86 FPU stack
Code containing inconsistent calling sequences in the same file is
normally rejected---see @ref{GLOBALS}.
-(Use, say, @code{ftnchek} to ensure
+(Use, say, @command{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 Pentium optimizations
-@cindex optimization, for Pentium
-@cindex 586/686 CPUs
@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
-Porting GNU CC}.
-
-For recent CPUs that don't have explicit support in
-the released version of @code{gcc}, it may still be possible to get
-improvements.
-For instance, the flags recommended for 586/686
-(Pentium(Pro)) chips for building the Linux kernel are:
-
-@smallexample
--m486 -malign-loops=2 -malign-jumps=2 -malign-functions=2
--fomit-frame-pointer
-@end smallexample
-
-@noindent @samp{-fomit-frame-pointer} will, however, inhibit debugging
-on x86 systems.
+@xref{Submodel Options,,Hardware Models and Configurations,gcc,Using the
+GNU Compiler Collection (GCC)}. For instance on an x86 system the
+compiler might have
+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
+@option{-march=pentium}.
+
+For recent CPUs that don't have explicit support in the released version
+of @command{gcc}, it @emph{might} still be possible to get improvements
+with certain @option{-m} options.
+
+@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 @option{-O}.
@node Trouble
@chapter Known Causes of Trouble with GNU Fortran
missing features that are too much work to add, and some are places
where people's opinions differ as to what is best.
-Information on bugs that show up when configuring, porting, building,
-or installing @code{g77} is not provided here.
-@xref{Problems Installing}.
-
To find out about major bugs discovered in the current release and
possible workarounds for them, see
@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
-@ref{Trouble,,Known Causes of Trouble with GNU CC,
-gcc,Using and Porting GNU CC}.)
+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 GCC,
+gcc,Using the GNU Compiler Collection (GCC)}.)
@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.
of this manual.
However, users of Linux-based systems (such as GNU/Linux)
-should review @uref{http://www.bitwizard.nl/sig11}, a source
+should review @uref{http://www.bitwizard.nl/sig11/}, a source
of detailed information on diagnosing hardware problems,
by recognizing their common symptoms.
@cindex unresolved reference (various)
@cindex linking error for user code
@cindex code, user
-@cindex @code{ld}, error linking user code
-@cindex @code{ld}, can't find strange names
+@cindex @command{ld}, error linking user code
+@cindex @command{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{ld}, error linking user code
+@cindex @command{ld}, error linking user code
@cindex code, user
-@cindex @code{ld}, can't find @samp{_main}
+@cindex @command{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 common blocks, large
@cindex large common blocks
@cindex linking, errors
-@cindex @code{ld}, errors
+@cindex @command{ld}, errors
@cindex errors, linker
On some older GNU/Linux systems, programs with common blocks larger
than 16MB cannot be linked without some kind of error
message being produced.
-This is a bug in older versions of @code{ld}, fixed in
+This is a bug in older versions of @command{ld}, fixed in
more recent versions of @code{binutils}, such as version 2.6.
@node Debugger Problems
@subsection Debugger Problems
-@cindex @code{gdb}, support
-@cindex support, @code{gdb}
-There are some known problems when using @code{gdb} on code
-compiled by @code{g77}.
+@cindex @command{gdb}, support
+@cindex support, @command{gdb}
+There are some known problems when using @command{gdb} on code
+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
of a @code{COMPLEX(KIND=2)} dummy array, on at least some GNU/Linux
machines, plus some others.
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}.)
+also known to crash recent versions of @command{gdb}.
+(@command{gdb}'s Fortran support was done for a different compiler
+and isn't properly compatible with @command{g77}.)
@node NeXTStep Problems
@subsection NeXTStep Problems
This leads to all sorts of trouble, from the executable simply not
executing, to bus errors.
-The NeXTStep command line tool @code{ebadexec} points to
+The NeXTStep command line tool @command{ebadexec} points to
the problem as follows:
@smallexample
@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
Often this can be cured by
increasing or removing your shell's limit on stack usage, typically
-using @kbd{limit stacksize} (in @code{csh} and derivatives) or
-@kbd{ulimit -s} (in @code{sh} and derivatives).
+using @kbd{limit stacksize} (in @command{csh} and derivatives) or
+@kbd{ulimit -s} (in @command{sh} and derivatives).
Increasing the allowed stack size might, however, require
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.
-@xref{Maximum Stackable Size}, for information on patching
-@code{g77} to use different criteria for placing local
-non-automatic 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
+on stack space) or permit larger-sized entities to be put on the
+stack (which can improve run-time performance, as it presents
+more opportunities for the GBE to optimize the generated code).
+
+@emph{Note:} Putting more variables and arrays on the stack
+might cause problems due to system-dependent limits on stack size.
+Also, the value of @code{FFECOM_sizeMAXSTACKITEM} has no
+effect on automatic variables and arrays.
+@xref{But-bugs}, for more information.
+@emph{Note:} While @code{libg2c} places a limit on the range
+of Fortran file-unit numbers, the underlying library and operating
+system might impose different kinds of limits.
+For example, some systems limit the number of files simultaneously
+open by a running program.
+Information on how to increase these limits should be found
+in your system's documentation.
@cindex automatic arrays
@cindex arrays, automatic
(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
@subsection Nothing Happens
@cindex nothing happens
@cindex naming programs
-@cindex @code{test} programs
-@cindex programs, @code{test}
+@cindex @command{test} programs
+@cindex programs, @command{test}
It is occasionally reported that a ``simple'' program,
such as a ``Hello, World!'' program, does nothing when
it is run, even though the compiler reported no errors,
simple @code{PRINT} statement.
This most often happens because the program has been
-compiled and linked on a UNIX system and named @code{test},
+compiled and linked on a UNIX system and named @command{test},
though other names can lead to similarly unexpected
run-time behavior on various systems.
Under UNIX and many other system, a simple command name
invokes a searching mechanism that might well not choose
the program located in the current working directory if
-there is another alternative (such as the @code{test}
+there is another alternative (such as the @command{test}
command commonly installed on UNIX systems).
The reliable way to invoke a program you just linked in
read up on how their shell searches for commands, how to
set their search path, and so on.
The relevant UNIX commands to learn about include
-@code{man}, @code{info} (on GNU systems), @code{setenv} (or
-@code{set} and @code{env}), @code{which}, and @code{find}.
+@command{man}, @command{info} (on GNU systems), @command{setenv} (or
+@command{set} and @command{env}), @command{which}, and @command{find}.
@node Strange Behavior at Run Time
@subsection Strange Behavior at Run Time
@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
Floating-Point Arithmetic', Computing Surveys, 23, March 1991, pp.@:
5-48.
An online version is available at
-@uref{http://docs.sun.com},
+@uref{http://docs.sun.com/},
and there is a supplemented version, in PostScript form, at
@uref{http://www.validgh.com/goldberg/paper.ps}.
Information related to the IEEE 754
floating-point standard by a leading light can be found at
-@uref{http://http.cs.berkeley.edu/%7Ewkahan/ieee754status};
+@uref{http://http.cs.berkeley.edu/%7Ewkahan/ieee754status/};
see also slides from the short course referenced from
@uref{http://http.cs.berkeley.edu/%7Efateman/}.
@uref{http://www.linuxsupportline.com/%7Ebillm/} has a brief
@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.)
* Suppressing Space Padding::
* Fortran Preprocessor::
* Bit Operations on Floating-point Data::
+* Really Ugly Character Assignments::
New facilities:
* POSIX Standard::
* Large Automatic Arrays::
* Support for Threads::
* Increasing Precision/Range::
+* Enabling Debug Lines::
Better diagnostics:
+* Better Warnings::
* Gracefully Handle Sensible Bad Code::
* Non-standard Conversions::
* Non-standard Intrinsics::
Run-time facilities:
* Uninitialized Variables at Run Time::
* Portable Unformatted Files::
+* Better List-directed I/O::
+* Default to Console I/O::
Debugging:
* Labels Visible to Debugger::
@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.
-This feature is considered to be absolutely vital, even though it
-is not standard-conforming, and is scheduled for version 0.6.
+@command{g77} doesn't allow intrinsics in @code{PARAMETER} statements.
-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.
In the meantime, version 0.5.18 provides rudimentary support
for them.
@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
machines will result in automatic support of @code{INTEGER*1},
@code{INTEGER*2}, @code{INTEGER*8}, maybe even @code{REAL*16},
and so on.
-This is scheduled for version 0.6.
@node Array Bounds Expressions
@subsection Array Bounds Expressions
@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).
-These are typically called either @code{fpr} or @code{asa}. You can get
-a version of @code{asa} from
+These are typically called either @command{fpr} or @command{asa}. You can get
+a version of @command{asa} from
@uref{ftp://sunsite.unc.edu/pub/Linux/devel/lang/fortran} for GNU
systems which will probably build easily on other systems.
-Alternatively, @code{fpr} is in BSD distributions in various archive
+Alternatively, @command{fpr} is in BSD distributions in various archive
sites.
@c (Can both programs can be used in a pipeline,
@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
END
@end smallexample
+@node Really Ugly Character Assignments
+@subsection Really Ugly Character Assignments
+
+An option such as @option{-fugly-char} should be provided
+to allow
+
+@smallexample
+REAL*8 A1
+DATA A1 / '12345678' /
+@end smallexample
+
+and:
+
+@smallexample
+REAL*8 A1
+A1 = 'ABCDEFGH'
+@end 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 an x86-based GNU system:
+on a GNU system using glibc 2.2 or newer:
@smallexample
-#include <fpu_control.h>
+#define _GNU_SOURCE 1
+#include <fenv.h>
static void __attribute__ ((constructor))
trapfpe ()
@{
- __setfpucw (_FPU_DEFAULT &
- ~(_FPU_MASK_IM | _FPU_MASK_ZM | _FPU_MASK_OM));
+ /* Enable some exceptions. At startup all exceptions are masked. */
+
+ feenableexcept (FE_INVALID|FE_DIVBYZERO|FE_OVERFLOW);
@}
@end smallexample
@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.
+@node Enabling Debug Lines
+@subsection Enabling Debug Lines
+@cindex debug line
+@cindex comment line, debug
+
+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}
+(as comment lines).
+
+@node Better Warnings
+@subsection Better Warnings
+
+Because of how @command{g77} generates code via the back end,
+it doesn't always provide warnings the user wants.
+Consider:
+
+@smallexample
+PROGRAM X
+PRINT *, A
+END
+@end smallexample
+
+Currently, the above is not flagged as a case of
+using an uninitialized variable,
+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!)
+
+Fixing this requires one of the following:
+
+@itemize @bullet
+@item
+Switch to new library, @code{libg77}, that provides
+a more ``clean'' interface,
+vis-a-vis input, output, and modified arguments,
+so the GBE can tell what's going on.
+
+This would provide a pretty big performance improvement,
+at least theoretically, and, ultimately, in practice,
+for some types of code.
+
+@item
+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
+involving a potentially uninitialized variable.
+
+This might also provide a performance boost for some code,
+because @samp{A} might then end up living in a register,
+which could help with inner loops.
+
+@item
+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.
+@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
+@subsection Better List-directed I/O
+
+Values output using list-directed I/O
+(@samp{PRINT *, R, D})
+should be written with a field width, precision, and so on
+appropriate for the type (precision) of each value.
+
+(Currently, no distinction is made between single-precision
+and double-precision values
+by @code{libf2c}.)
+
+It is likely this item will require the @code{libg77} project
+to be undertaken.
+
+In the meantime, use of formatted I/O is recommended.
+While it might be of little consolation,
+@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
+of the precision of a data type,
+perhaps controlled by preprocessing directives.
+
+@node Default to Console I/O
+@subsection Default to Console I/O
+
+The default I/O units,
+specified by @samp{READ @var{fmt}},
+@samp{READ (UNIT=*)},
+@samp{WRITE (UNIT=*)}, and
+@samp{PRINT @var{fmt}},
+should not be units 5 (input) and 6 (output),
+but, rather, unit numbers not normally available
+for use in statements such as @code{OPEN} and @code{CLOSE}.
+
+Changing this would allow a program to connect units 5 and 6
+to files via @code{OPEN},
+but still use @samp{READ (UNIT=*)} and @samp{PRINT}
+to do I/O to the ``console''.
+
+This change probably requires the @code{libg77} project.
+
@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
@node Backslash in Constants
@subsection Backslash in Constants
@cindex backslash
-@cindex @code{f77} support
-@cindex support, @code{f77}
+@cindex @command{f77} support
+@cindex support, @command{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 @command{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.
-
-However, the realization that @code{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}
+purity, to make @option{-fno-backslash} the default for GNU
+Fortran and thus require users of UNIX @command{f77} and @command{f2c}
+to specify @option{-fbackslash} to get the UNIX behavior.
+
+However, the realization that @command{g77} is intended as
+a replacement for @emph{UNIX} @command{f77}, caused the author
+to choose to make @command{g77} as compatible with
+@command{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
+a replacement for @command{f77} to do, by default?''
+Although at least one UNIX @command{f77} does not provide
+@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.
+the majority of code that is compiled by UNIX @command{f77}
+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
-with @code{f77},
+with @command{f77},
and when it is, new build procedures (shell scripts,
makefiles, and so on) must be set up anyway so that
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
-exist for the majority of UNIX @code{f77} users who
+@command{g77}'s default of @option{-fbackslash} than would
+exist for the majority of UNIX @command{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
-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.
-@c
-@c Say this when it is true -- hopefully 0.6, maybe 0.7 or later. --burley
-@c
-@c GNU Fortran always tries to compile your program if possible; it never
-@c gratuitously rejects a program whose meaning is clear merely because
-@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 This does not mean that @emph{all} non-ANSI constructs get warnings
-@c or errors.
+is printed in most @command{g77} diagnostics.
@xref{Warning Options,,Options to Request or Suppress Warnings}, for
more detail on these and related command-line options.
* Criteria: Bug Criteria. Have you really found a bug?
* Where: Bug Lists. Where to send your bug report.
* Reporting: Bug Reporting. How to report a bug effectively.
-* Patches: Sending Patches. How to send a patch for GNU Fortran.
@end menu
@xref{Trouble,,Known Causes of Trouble with GNU Fortran},
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
@pindex ftnchek
-Validate your code with @code{ftnchek} or a similar code-checking
+Validate your code with @command{ftnchek} or a similar code-checking
tool.
-@code{ftnchek} can be found at @uref{ftp://ftp.netlib.org/fortran}
+@command{ftnchek} can be found at @uref{ftp://ftp.netlib.org/fortran}
or @uref{ftp://ftp.dsm.fordham.edu}.
@pindex make
@cindex Makefile example
-Here are some sample @file{Makefile} rules using @code{ftnchek}
-``project'' files to do cross-file checking and @code{sfmakedepend}
+Here are some sample @file{Makefile} rules using @command{ftnchek}
+``project'' files to do cross-file checking and @command{sfmakedepend}
(from @uref{ftp://ahab.rutgers.edu/pub/perl/sfmakedepend})
to maintain dependencies automatically.
-These assume the use of GNU @code{make}.
+These assume the use of GNU @command{make}.
@smallexample
# Dummy suffix for ftnchek targets:
@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
your program's source file format contains ``interesting'' things
like trailing spaces or strange characters, or if you need to
include binary data files, it is acceptable to put all the
-files together in a @code{tar} archive, and, whether you need to
-do that, it is acceptable to then compress the single file (@code{tar}
+files together in a @command{tar} archive, and, whether you need to
+do that, it is acceptable to then compress the single file (@command{tar}
archive or source file)
-using @code{gzip} and encode it via @code{uuencode}.
+using @command{gzip} and encode it via @command{uuencode}.
Do not use any MIME stuff---the current maintainer can't decode this.
-Using @code{compress} instead of @code{gzip} is acceptable, assuming
+Using @command{compress} instead of @command{gzip} is acceptable, assuming
you have licensed the use of the patented algorithm in
-@code{compress} from Unisys.)
+@command{compress} from Unisys.)
To enable someone to investigate the bug, you should include all these
things:
@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
don't see clearly represented in that output.)
@item
-The operands you gave to the @code{configure} command when you installed
+The operands you gave to the @command{configure} command when you installed
the compiler.
@item
@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.
What you need to provide in addition to a backtrace are the values of
the local variables for several stack frames up. When a local
variable or an argument is an RTX, first print its value and then use
-the GDB command @code{pr} to print the RTL expression that it points
+the GDB command @command{pr} to print the RTL expression that it points
to. (If GDB doesn't run on your machine, use your debugger to call
the function @code{debug_rtx} with the RTX as an argument.) In
general, whenever a variable is a pointer, its value is no use
patch should be an improvement, we won't install it. A test case will
help us to understand.
-@xref{Sending Patches}, for guidelines on how to make it easy for us to
+See @uref{http://gcc.gnu.org/contribute.html}
+for guidelines on how to make it easy for us to
understand and install your patches.
@item
we should be able to reproduce the crash ourselves.
@end itemize
-@node Sending Patches
-@section Sending Patches for GNU Fortran
-
-If you would like to write bug fixes or improvements for the GNU Fortran
-compiler, that is very helpful.
-Send suggested fixes to the bug report
-mailing list, @email{@value{email-bugs}}.
-
-Please follow these guidelines so we can study your patches efficiently.
-If you don't follow these guidelines, your information might still be
-useful, but using it will take extra work. Maintaining GNU Fortran is a lot
-of work in the best of circumstances, and we can't keep up unless you do
-your best to help.
-
-@itemize @bullet
-@item
-Send an explanation with your changes of what problem they fix or what
-improvement they bring about. For a bug fix, just include a copy of the
-bug report, and explain why the change fixes the bug.
-
-(Referring to a bug report is not as good as including it, because then
-we will have to look it up, and we have probably already deleted it if
-we've already fixed the bug.)
-
-@item
-Always include a proper bug report for the problem you think you have
-fixed. We need to convince ourselves that the change is right before
-installing it. Even if it is right, we might have trouble judging it if
-we don't have a way to reproduce the problem.
-
-@item
-Include all the comments that are appropriate to help people reading the
-source in the future understand why this change was needed.
-
-@item
-Don't mix together changes made for different reasons.
-Send them @emph{individually}.
-
-If you make two changes for separate reasons, then we might not want to
-install them both. We might want to install just one. If you send them
-all jumbled together in a single set of diffs, we have to do extra work
-to disentangle them---to figure out which parts of the change serve
-which purpose. If we don't have time for this, we might have to ignore
-your changes entirely.
-
-If you send each change as soon as you have written it, with its own
-explanation, then the two changes never get tangled up, and we can
-consider each one properly without any extra work to disentangle them.
-
-Ideally, each change you send should be impossible to subdivide into
-parts that we might want to consider separately, because each of its
-parts gets its motivation from the other parts.
-
-@item
-Send each change as soon as that change is finished. Sometimes people
-think they are helping us by accumulating many changes to send them all
-together. As explained above, this is absolutely the worst thing you
-could do.
-
-Since you should send each change separately, you might as well send it
-right away. That gives us the option of installing it immediately if it
-is important.
-
-@item
-Use @samp{diff -c} to make your diffs. Diffs without context are hard
-for us to install reliably. More than that, they make it hard for us to
-study the diffs to decide whether we want to install them. Unidiff
-format is better than contextless diffs, but not as easy to read as
-@samp{-c} format.
-
-If you have GNU @code{diff}, use @samp{diff -cp}, which shows the name of the
-function that each change occurs in.
-(The maintainer of GNU Fortran currently uses @samp{diff -rcp2N}.)
-
-@item
-Write the change log entries for your changes. We get lots of changes,
-and we don't have time to do all the change log writing ourselves.
-
-Read the @file{ChangeLog} file to see what sorts of information to put
-in, and to learn the style that we use. The purpose of the change log
-is to show people where to find what was changed. So you need to be
-specific about what functions you changed; in large functions, it's
-often helpful to indicate where within the function the change was.
-
-On the other hand, once you have shown people where to find the change,
-you need not explain its purpose. Thus, if you add a new function, all
-you need to say about it is that it is new. If you feel that the
-purpose needs explaining, it probably does---but the explanation will be
-much more useful if you put it in comments in the code.
-
-If you would like your name to appear in the header line for who made
-the change, send us the header line.
-
-@item
-When you write the fix, keep in mind that we can't install a change that
-would break other systems.
-
-People often suggest fixing a problem by changing machine-independent
-files such as @file{toplev.c} to do something special that a particular
-system needs. Sometimes it is totally obvious that such changes would
-break GNU Fortran for almost all users. We can't possibly make a change like
-that. At best it might tell us how to write another patch that would
-solve the problem acceptably.
-
-Sometimes people send fixes that @emph{might} be an improvement in
-general---but it is hard to be sure of this. It's hard to install
-such changes because we have to study them very carefully. Of course,
-a good explanation of the reasoning by which you concluded the change
-was correct can help convince us.
-
-The safest changes are changes to the configuration files for a
-particular machine. These are safe because they can't create new bugs
-on other machines.
-
-Please help us keep up with the workload by designing the patch in a
-form that is good to install.
-@end itemize
-
@node Service
@chapter How To Get Help with GNU Fortran
GNU CC distribution.
@item
-Send a message to @email{@value{email-general}}.
+Send a message to @email{@value{email-help}}.
@end itemize
@end ifset
@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{lang_options} array
+This list goes into the @code{documented_lang_options} array
in @file{gcc/toplev.c}, which uses this array to
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 EGCS-1.0
-@itemx FSF
-Change the way @code{f771} handles the @samp{-fset-g77-defaults}
+@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 @command{g77}
+perform internal consistency checking automatically
+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 @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.
-
-@item EGCS-1.1
-@itemx EGCS-1.2
-Change the @code{lang_init_options} routine in @file{egcs/gcc/f/com.c}.
-
-(Note that these versions of @code{g77}
-perform internal consistency checking automatically
-when the @samp{-fversion} option is specified.)
@end table
@node Projects
@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.
-Much of this should be done only after the redesign planned for
-0.6 is complete.
+Better info on how @command{g77} works and how to port it is needed.
@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.
-Identification uses the GNU Info format---specifically, the @code{info}
+Identification uses the GNU Info format---specifically, the @command{info}
command that displays the explanation is given within square
brackets in the diagnostic.
For example:
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}.
+@xref{Overall Options,,Options Controlling the Kind of
+Output,gcc,Using the GNU Compiler Collection (GCC)}.
@item
The source file is preprocessed, and the results of preprocessing
@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
-@smallexample
-If the above command failed due to an unresolved reference
-to strtoul, _strtoul, bsearch, _bsearch, or similar, see
-[info -f g77 M LINKFAIL] (a node in the g77 documentation)
-for information on what causes this, how to work around
-the problem by editing $@{srcdir@}/proj.c, and what else to do.
-@end smallexample
-
-@xref{Missing strtoul or bsearch}, for more information on
-this problem,
-which occurs only in releases of @code{g77}
-based on @code{gcc}.
-(It does not occur in @code{egcs}.)
-
-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'
@unnumbered Index
@printindex cp
-@summarycontents
-@contents
@bye
OSDN Git Service
