@c %**start of header
@setfilename g77.info
-@set last-update 1999-04-03
+@set last-update 1999-04-17
@set copyrights-g77 1995-1999
@include root.texi
@item Shorthand Options
@xref{Shorthand Options}.
@smallexample
--ff66 -fno-f66 -ff77 -fno-f77 -fugly -fno-ugly
+-ff66 -fno-f66 -ff77 -fno-f77 -fno-ugly
@end smallexample
@item Fortran Language Options
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 @samp{cpp} by using
+You can force @samp{.f} files to be preprocessed by @code{cpp} by using
@samp{-x f77-cpp-input}.
@xref{LEX}.
This option is obsolete in @code{egcs}
as of version 1.1.
The effect is instead achieved
-by the @samp{lang_init_options} routine
+by the @code{lang_init_options} routine
in @file{egcs/gcc/f/com.c}.
@cindex consistency checks
@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:
in old code.
@xref{Distensions}, for more information.
-@emph{Note:} The @samp{-fugly} option is likely to
-be removed in a future version.
-Implicitly enabling all the @samp{-fugly-*} options
-is unlikely to be feasible, or sensible, in the future,
-so users should learn to specify only those
-@samp{-fugly-*} options they really need for a
-particular source file.
-
@cindex -fno-ugly option
@cindex options, -fno-ugly
@item -fno-ugly
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. @code{-ffloat-store}
+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
@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 @code{-funroll-loops}
+of @code{DO WHILE}, this option is equivalent to @samp{-funroll-loops}
but possibly slower.
@item -fno-move-all-movables
@item
A metasyntactic variable---that is, a name used in this document
to serve as a placeholder for whatever text is used by the
-user or programmer--appears as shown in the following example:
+user or programmer---appears as shown in the following example:
``The @code{INTEGER @var{ivar}} statement specifies that
@var{ivar} is a variable or array of type @code{INTEGER}.''
and certainly existing Fortran programs, disagree about the
meaning of such invocations.
-The first version of @samp{JCB002} didn't accommodate some compilers'
+The first version of @code{JCB002} didn't accommodate some compilers'
treatment of @samp{INT(I1-I2)} where @samp{I1} and @samp{I2} are
@code{INTEGER*2}.
In such a case, these compilers apparently convert both
of programs compiled by these various compilers show that they
all implement either @samp{Interp 1} or @samp{Interp 2} above.
-Specifically, it is believed that the new version of @samp{JCB002}
+Specifically, it is believed that the new version of @code{JCB002}
above will confirm that:
@itemize @bullet
Note 2: Rules for InitialCaps names are:
-@itemize --
+@itemize @minus
@item
Must be a single uppercase letter, @strong{or}
@item
not.
Note that most, but not all, built-in names meet these
requirements---the exceptions are some of the two-letter format
-specifiers, such as @samp{BN} and @samp{BZ}.
+specifiers, such as @code{BN} and @code{BZ}.
Here are the names of the corresponding command-line options:
@code{g77} treats double-quote (@samp{"})
as beginning an octal constant of @code{INTEGER(KIND=1)} type
-when the @code{-fvxt} option is specified.
+when the @samp{-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 @code{-fvxt} option permits this:
+For example, the @samp{-fvxt} option permits this:
@example
PRINT *, "20
as a continuation character rather than
as the beginning of a comment
(as it does in any other column)
-when the @code{-fvxt} option is specified.
+when the @samp{-fvxt} option is specified.
The following program, when run, prints a message indicating
whether it is interpreted according to GNU Fortran (and Fortran 90)
Automatic conversion of numeric
expressions to @code{INTEGER(KIND=1)} in contexts such as:
-@itemize --
+@itemize @minus
@item
Array-reference indexes.
@item
These are humorously referred to as ``distensions'',
extensions that just plain look ugly in the harsh light of day.
-@emph{Note:} The @samp{-fugly} option, which currently serves
-as shorthand to enable all of the distensions below, is likely to
-be removed in a future version of @code{g77}.
-That's because it's likely new distensions will be added that
-conflict with existing ones in terms of assigning meaning to
-a given chunk of code.
-(Also, it's pretty clear that users should not use @samp{-fugly}
-as shorthand when the next release of @code{g77} might add a
-distension to that that causes their existing code, when recompiled,
-to behave differently---perhaps even fail to compile or run
-correctly.)
-
@menu
* Ugly Implicit Argument Conversion:: Disabled via @samp{-fno-ugly-args}.
* Ugly Assumed-Size Arrays:: Enabled via @samp{-fugly-assumed}.
Normally, for portability and improved diagnostics, @code{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-@samp{FORMAT}-I/O
+the corresponding assigned-@code{GOTO} and assigned-@code{FORMAT}-I/O
statements that reference the variable).
However, some code (that violates the ANSI FORTRAN 77 standard)
The @code{libg2c} library
shipped with any @code{g77} that warns
about invocation of a non-Y2K-compliant intrinsic
-has renamed the @samp{EXTERNAL} procedure names
+has renamed the @code{EXTERNAL} procedure names
of those intrinsics.
This is done so that
the @code{libg2c} implementations of these intrinsics
cannot be directly linked to
-as @samp{EXTERNAL} names
+as @code{EXTERNAL} names
(which normally would avoid the non-Y2K-intrinsic warning).
-The renamed forms of the @samp{EXTERNAL} names
+The renamed forms of the @code{EXTERNAL} names
of these renamed procedures
may be linked to
by appending the string @samp{_y2kbug}
CALL VXTIDATE_Y2KBUG (MM, DD, YY)
@end smallexample
-(Note that the @samp{EXTERNAL} statement
+(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}.
But it is shown in this specific case,
for purposes of illustration.)
-The renaming of @samp{EXTERNAL} procedure names of these intrinsics
+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}
as, in C, @samp{date_(&str, 20);}.
-This, in turn, links to the @samp{date_} procedure
-in the @samp{libE77} portion of @code{libg2c},
+This, in turn, links to the @code{date_} procedure
+in the @code{libE77} portion of @code{libg2c},
which purposely calls a nonexistent procedure
-named @samp{G77_date_y2kbuggy_0}.
+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.
-Generally, we recommend that the @samp{EXTERNAL} method
+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
is skipped.
In particular, it is probably better to use the
-@samp{INTRINSIC} method of invoking
+@code{INTRINSIC} method of invoking
non-Y2K-compliant procedures,
so anyone compiling the code
can quickly notice the potential Y2K problems
(invoking one of the intrinsics in question)
to an old library
might yield an unresolved reference
-to @samp{G77_date_y2kbug_0}.
-(The old library calls it @samp{G77_date_0}.)
+to @code{G77_date_y2kbug_0}.
+(The old library calls it @code{G77_date_0}.)
Similarly, linking previously-compiled code
to a new library
might yield an unresolved reference
-to @samp{G77_vxtidate_0}.
-(The new library calls it @samp{G77_vxtidate_y2kbug_0}.)
+to @code{G77_vxtidate_0}.
+(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}
@pindex f2c
@cindex cfortran.h
@cindex Netlib
-Even if you don't actually use it as a compiler, @samp{f2c} from
+Even if you don't actually use it as a compiler, @code{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}}.
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 @samp{int}s, for instance; instead, declare them as
+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
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 @samp{END} statements.
+arguments plus @code{END} statements.
Then run @code{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.
@samp{-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 @samp{ftnchek} tool from @uref{ftp://ftp.netlib.org/fortran}
+the @code{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
@cindex statements, PROGRAM
When @code{g77} compiles a main program unit, it gives it the public
-procedure name @samp{MAIN__}.
+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 @samp{MAIN__}.
+activity and then calls @code{MAIN__}.
Generally, @code{g77} and @code{libg2c} are designed so that you need not
include a main program unit written in Fortran in your program---it
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 @samp{MAIN__}, and then run the program.
+the entrance to @code{MAIN__}, and then run the program.
A convenient way to do so is to add the @code{gdb} command
@example
Of course, if you really want to set a break point at some
other place in your program and just start the program
-running, without first breaking at @samp{MAIN__},
+running, without first breaking at @code{MAIN__},
that should work fine.
@node Procedures
so you can more easily change the actual numbers in the future.
The information below is culled from the definition
-of @samp{F_err} in @file{f/runtime/libI77/err.c} in the
+of @code{F_err} in @file{f/runtime/libI77/err.c} in the
@code{g77} source tree.
@smallexample
For several versions prior to 0.5.20, @code{g77} configured its
version of the @code{libf2c} run-time library so that one of
-its configuration macros, @samp{ALWAYS_FLUSH}, was defined.
+its configuration macros, @code{ALWAYS_FLUSH}, was defined.
This was done as a result of a belief that many programs expected
output to be flushed to the operating system (under UNIX, via
@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 @samp{ALWAYS_FLUSH} macro defined.
+can be built and installed with the @code{ALWAYS_FLUSH} macro defined.
@node Large File Unit Numbers
@subsection Large File Unit Numbers
@code{libg2c}.
Normally, this range is 0 through 99, and the high end
of the range is controlled by a @code{libg2c} source-file
-macro named @samp{MXUNIT}.
+macro named @code{MXUNIT}.
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 @samp{MXUNIT} in @code{libg2c} so you can build and
+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.
@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 @code{-ffloat-store} option or to reset the precision flag on the
+the @samp{-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 @code{-ffloat-store}. On x86
+mode and not take the performance hit of @samp{-ffloat-store}. On x86
and m68k GNU systems you can do this with a technique similar to that
for turning on floating-point exceptions @xref{Floating-point Exception
Handling}. The control word could be set to double precision by
@code{RECURSIVE} procedures or other means of explicitly
specifying that variables or arrays are automatic.
-@cindex -fugly option
-@cindex options, -fugly
-@item -fugly
-Fix the source code so that @samp{-fno-ugly} will work.
-Note that, for many programs, it is difficult to practically
-avoid using the features enabled via @samp{-fugly-init}, and these
-features pose the lowest risk of writing nonportable code, among the
-various ``ugly'' features.
-
@cindex -f@var{group}-intrinsics-hide option
@cindex options, -f@var{group}-intrinsics-hide
@item -f@var{group}-intrinsics-hide
@subsection Nothing Happens
@cindex nothing happens
@cindex naming programs
-@cindex @samp{test} programs
-@cindex programs, @samp{test}
+@cindex @code{test} programs
+@cindex programs, @code{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 @samp{test},
+compiled and linked on a UNIX system and named @code{test},
though other names can lead to similarly unexpected
run-time behavior on various systems.
Since @samp{0.2} in the program is a single-precision value, it
is converted to double precision (still in binary notation)
before being converted back to decimal.
-The conversion to binary appends _binary_ zero digits to the
+The conversion to binary appends @emph{binary} zero digits to the
original value---which, again, is an inexact approximation of
0.2---resulting in an approximation that is much less exact
than is connoted by the use of double precision.
A useful source of information on floating-point computation is David
Goldberg, `What Every Computer Scientist Should Know About
Floating-Point Arithmetic', Computing Surveys, 23, March 1991, pp.@:
-5--48.
+5-48.
An online version is available at
@uref{http://docs.sun.com},
and there is a supplemented version, in PostScript form, at
* Array Bounds Expressions::
* POINTER Statements::
* Sensible Non-standard Constructs::
+* READONLY Keyword::
* FLUSH Statement::
* Expressions in FORMAT Statements::
* Explicit Assembler Code::
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 @code{-Wno-col73to80} option.
+having to specify, say, a @samp{-Wno-col73to80} option.
@node Fortran 90 Support
@subsection Fortran 90 Support
bug report with an explanation, so we can consider
fixing @code{g77} just for cases like yours.
+@node READONLY Keyword
+@subsection @code{READONLY} Keyword
+@cindex READONLY
+
+Support for @code{READONLY}, in @code{OPEN} statements,
+requires @code{libg2c} support,
+to make sure that @samp{CLOSE(@dots{},STATUS='DELETE')}
+does not delete a file opened on a unit
+with the @code{READONLY} keyword,
+and perhaps to trigger a fatal diagnostic
+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}
+(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!
+
+Further, mounting of non-UNIX filesystems on UNIX systems
+(such as via NFS)
+might require proper @code{READONLY} support.
+
+@cindex SHARED
+(Similar issues might be involved with supporting the @code{SHARED}
+keyword.)
+
@node FLUSH Statement
@subsection @code{FLUSH} Statement
@cindex automatic variables
@cindex variables, automatic
-@code{g77} doesn't support the @code{AUTOMATIC} keyword that
+@code{g77} doesn't support the @code{AUTOMATIC} statement that
@code{f2c} does.
-It is not yet clear exactly what this statement would achieve.
-The semantic equivalent would be provided by @code{RECURSIVE}
-combined with lack of @code{SAVE}.
-In that sense, perhaps all it would provide is an
-overriding of an unadorned (blanket) @code{SAVE} statement
-for specific variables.
+@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.
+
+@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.
+
+@code{AUTOMATIC} would not, by itself, designate the containing procedure
+as recursive.
-It might also serve as a hint to the compiler that placing
-even a very large array on the stack is acceptable.
+@code{AUTOMATIC} should work syntactically like @code{SAVE},
+in that @code{AUTOMATIC} with no variables listed should apply to
+all pertinent variables and arrays
+(which would not include common blocks or their members).
-Perhaps it should disallow @code{DATA}
-or other specification of any initial values
-for affected variables as well.
+Variables and arrays denoted as @code{AUTOMATIC}
+would not be permitted to be initialized via @code{DATA}
+or other specification of any initial values,
+requiring explicit initialization,
+such as via assignment statements.
+
+@cindex UNSAVE
+@cindex STATIC
+Perhaps @code{UNSAVE} and @code{STATIC},
+as strict semantic opposites to @code{SAVE} and @code{AUTOMATIC},
+should be provided as well.
@node Suppressing Space Padding
@subsection Suppressing Space Padding of Source Lines
@smallexample
gcc -o libtrapfpe.a trapfpe.c
@end smallexample
-and then use it by adding @code{-trapfpe} to the @code{g77} command line
+and then use it by adding @samp{-trapfpe} to the @code{g77} command line
when linking.
@node Nonportable Conversions
quietly accept.
Some of these conversions are accepted by @code{g77}
-when the @samp{-fugly} option is specified.
+when the @samp{-fugly-logint} option is specified.
Perhaps it should accept more or all of them.
@node Large Automatic Arrays
@cindex logical expressions, comparing
Use of @code{.EQ.} and @code{.NE.} on @code{LOGICAL} operands
-is not supported, except via @samp{-fugly}, which is not
+is not supported, except via @samp{-fugly-logint}, which is not
recommended except for legacy code (where the behavior expected
by the @emph{code} is assumed).
you, without knowing more context, whether the @samp{&} and @samp{-}
operators are infix (binary) or unary!)
+Most dangerous of all is the fact that,
+even assuming consensus on its meaning,
+an expression like @samp{L.AND.M.EQ.N},
+if it is the result of a typographical error,
+doesn't @emph{look} like it has such a typo.
+Even experienced Fortran programmers would not likely notice that
+@samp{L.AND.M.EQV.N} was, in fact, intended.
+
+So, this is a prime example of a circumstance in which
+a quality compiler diagnoses the code,
+instead of leaving it up to someone debugging it
+to know to turn on special compiler options
+that might diagnose it.
+
@node Order of Side Effects
@subsection Order of Side Effects
@cindex side effects, order of evaluation
which is used during the build of @code{gcc} to
build a list of all options that are accepted by
at least one language's compiler.
-This list goes into the @samp{lang_options} array
+This list goes into the @code{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 @samp{lang_option_decode}, which, for
+by calling @code{lang_option_decode}, which, for
@code{g77}, is in @file{@value{path-g77}/com.c} and just
-calls @samp{ffe_decode_option}.
+calls @code{ffe_decode_option}.
If the linked-in front end ``rejects'' a
particular option passed to it, @file{toplev.c}
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;
-even though the @code{f771} version of @samp{lang_decode_option}
+even though the @code{f771} version of @code{lang_decode_option}
rejects @samp{-fno-asm}, @file{toplev.c} doesn't
produce a diagnostic because some other language (C)
does accept it.
possible.
Code that processes Fortran options is found in
-@file{@value{path-g77}/top.c}, function @samp{ffe_decode_option}.
+@file{@value{path-g77}/top.c}, function @code{ffe_decode_option}.
This code needs to check positive and negative forms
of each option.
in the @code{g77} FFE, are defined in @file{@value{path-g77}/top.h}.
@emph{Compiler options} are listed in @file{gcc/toplev.c}
-in the array @samp{f_options}.
-An option not listed in @samp{lang_options} is
-looked up in @samp{f_options} and handled from there.
+in the array @code{f_options}.
+An option not listed in @code{lang_options} is
+looked up in @code{f_options} and handled from there.
The defaults for compiler options are set in the
global definitions for the corresponding variables,
option, which is always provided as the first option when
called by @code{g77} or @code{gcc}.
-This code is in @samp{ffe_decode_options} in @file{@value{path-g77}/top.c}.
+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.
@item EGCS-1.1
@itemx EGCS-1.2
-Change the @samp{lang_init_options} routine in @file{egcs/gcc/f/com.c}.
+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
@itemize @bullet
@item
-Improve @samp{malloc} package and its uses to specify more info about
+Improve @code{malloc} package and its uses to specify more info about
memory pools and, where feasible, use obstacks to implement them.
@item
@item
Throughout @code{g77}, don't pass line/column pairs where
-a simple @samp{ffewhere} type, which points to the error as much as is
-desired by the configuration, will do, and don't pass @samp{ffelexToken} types
-where a simple @samp{ffewhere} type will do.
+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.
Then, allow new default
-configuration of @samp{ffewhere} such that the source line text is not
+configuration of @code{ffewhere} such that the source line text is not
preserved, and leave it to things like Emacs' next-error function
to point to them (now that @samp{next-error} supports column,
or, perhaps, character-offset, numbers).
@item
When doing @samp{CHAR_VAR = CHAR_FUNC(@dots{})},
and it's clear that types line up
-and @samp{CHAR_VAR} is addressable or not a @samp{VAR_DECL},
+and @samp{CHAR_VAR} is addressable or not a @code{VAR_DECL},
make @samp{CHAR_VAR}, not a
temporary, be the receiver for @samp{CHAR_FUNC}.
(This is now done for @code{COMPLEX} variables.)
@code{gcc} rather than @code{f2c} calling conventions.)
@item
-Do something useful with @samp{doiter} references where possible.
+Do something useful with @code{doiter} references where possible.
For example, @samp{CALL FOO(I)} cannot modify @samp{I} if within
a @code{DO} loop that uses @samp{I} as the
iteration variable, and the back end might find that info useful
@itemize @bullet
@item
-Switch to using @samp{REAL_VALUE_TYPE} to represent floating-point constants
+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
to achieve desired implementation dialect via @file{proj.h}.
@item
-Clean up used tokens and @samp{ffewhere}s in @samp{ffeglobal_terminate_1}.
+Clean up used tokens and @code{ffewhere}s in @code{ffeglobal_terminate_1}.
@item
-Replace @file{sta.c} @samp{outpooldisp} mechanism with @samp{malloc_pool_use}.
+Replace @file{sta.c} @code{outpooldisp} mechanism with @code{malloc_pool_use}.
@item
-Check for @samp{opANY} in more places in @file{com.c}, @file{std.c},
+Check for @code{opANY} in more places in @file{com.c}, @file{std.c},
and @file{ste.c}, and get rid of the @samp{opCONVERT(opANY)} kludge
(after determining if there is indeed no real need for it).
in the code@dots{}uh@dots{}in the code.
@item
-Some @samp{ffebld_new} calls (those outside of @file{ffeexpr.c} or
-inside but invoked via paths not involving @samp{ffeexpr_lhs} or
-@samp{ffeexpr_rhs}) might be creating things
+Some @code{ffebld_new} calls (those outside of @file{ffeexpr.c} or
+inside but invoked via paths not involving @code{ffeexpr_lhs} or
+@code{ffeexpr_rhs}) might be creating things
in improper pools, leading to such things staying around too long or
(doubtful, but possible and dangerous) not long enough.
@item
-Some @samp{ffebld_list_new} (or whatever) calls might not be matched by
-@samp{ffebld_list_bottom} (or whatever) calls, which might someday matter.
+Some @code{ffebld_list_new} (or whatever) calls might not be matched by
+@code{ffebld_list_bottom} (or whatever) calls, which might someday matter.
(It definitely is not a problem just yet.)
@item
Probably not doing clean things when we fail to @code{EQUIVALENCE} something
due to alignment/mismatch or other problems---they end up without
-@samp{ffestorag} objects, so maybe the backend (and other parts of the front
-end) can notice that and handle like an @samp{opANY} (do what it wants, just
+@code{ffestorag} objects, so maybe the backend (and other parts of the front
+end) can notice that and handle like an @code{opANY} (do what it wants, just
don't complain or crash).
Most of this seems to have been addressed
by now, but a code review wouldn't hurt.
@item
When @code{FUNCTION} and @code{ENTRY} point types disagree (@code{CHARACTER}
lengths, type classes, and so on),
-@samp{ANY}-ize the offending @code{ENTRY} point and any @emph{new} dummies
+@code{ANY}-ize the offending @code{ENTRY} point and any @emph{new} dummies
it specifies.
@item
* INTGLOB:: Intrinsic also used as name of global.
* LEX:: Various lexer messages
* GLOBALS:: Disagreements about globals.
-* LINKFAIL:: When linking @samp{f771} fails.
+* LINKFAIL:: When linking @code{f771} fails.
* Y2KBAD:: Use of non-Y2K-compliant intrinsic.
@end menu
@itemize @bullet
@item
Change it to @samp{DBLE(@var{expr})} (if @var{intrinsic} is
-@samp{REAL}) or @samp{DIMAG(@var{expr})} (if @var{intrinsic}
-is @samp{AIMAG})
+@code{REAL}) or @samp{DIMAG(@var{expr})} (if @var{intrinsic}
+is @code{AIMAG})
if it expected the Fortran 90 interpretation.
This assumes @var{expr} is @code{COMPLEX(KIND=2)}---if it is
CALL XYZZY_RESET
@end smallexample
-However, that leaves the first @samp{C} in the @samp{CALL}
+However, that leaves the first @samp{C} in the @code{CALL}
statement in column 6, making it a comment line, which is
not really what the author intended, and which is likely
to result in one of the above-listed diagnostics.
@emph{Replacing} the @samp{C} in column 1 with a space
-is the proper change to make, to ensure the @samp{CALL}
+is the proper change to make, to ensure the @code{CALL}
keyword starts in or after column 7.
Another common mistake like this is to forget that fixed-form
* GNU C Required:: Why even ANSI C is not enough.
* Patching GNU CC:: Why @code{gcc} needn't be patched.
* Building GNU CC Necessary:: Why you can't build @emph{just} Fortran.
-* Missing strtoul or bsearch:: When linking @samp{f771} fails.
+* Missing strtoul or bsearch:: When linking @code{f771} fails.
* Cleanup Kills Stage Directories:: For @code{g77} developers.
-* LANGUAGES Macro Ignored:: Sometimes @samp{LANGUAGES} is ignored.
+* LANGUAGES Macro Ignored:: Sometimes @code{LANGUAGES} is ignored.
@end menu
@node GNU C Required
@ifclear OMIT-FSF-G77
On SunOS4 systems, linking the @code{f771} program used to
produce an error message concerning an undefined symbol named
-@samp{_strtoul}, because the @samp{strtoul} library function
+@samp{_strtoul}, because the @code{strtoul} library function
is not provided on that system.
Other systems have, in the past, been reported to not provide
-their own @samp{strtoul} or @samp{bsearch} function.
+their own @code{strtoul} or @code{bsearch} function.
Some versions @code{g77} tried to default to providing bare-bones
versions of @code{bsearch} and @code{strtoul} automatically,
required routines, the bare-bones versions are still provided,
in @file{@value{path-g77}/proj.c},
if the appropriate macros are defined.
-These are @code{NEED_BSEARCH} for @samp{bsearch} and
-@code{NEED_STRTOUL} for @samp{NEED_STRTOUL}.
+These are @code{NEED_BSEARCH} for @code{bsearch} and
+@code{NEED_STRTOUL} for @code{NEED_STRTOUL}.
Therefore, if you are sure your system is missing
@code{bsearch} or @code{strtoul} in its library,
@end smallexample
If you then encounter problems compiling @file{@value{path-g77}/proj.c},
-it might be due to a discrepancy between how @samp{bsearch}
-or @samp{strtoul} are defined by that file and how they're
+it might be due to a discrepancy between how @code{bsearch}
+or @code{strtoul} are defined by that file and how they're
declared by your system's header files.
In that case, you'll have to use some basic knowledge of C
@node LANGUAGES Macro Ignored
@subsubsection LANGUAGES Macro Ignored
-@cindex @samp{LANGUAGES} macro ignored
-@cindex ignoring @samp{LANGUAGES} macro
+@cindex @code{LANGUAGES} macro ignored
+@cindex ignoring @code{LANGUAGES} macro
Prior to version 0.5.23 of @code{g77}
and version 1.1 of @code{egcs},
@code{g77} would sometimes ignore
-the absence of @samp{f77} and @samp{F77} in the
-@samp{LANGUAGES} macro definition used for the
+the absence of @code{f77} and @code{F77} in the
+@code{LANGUAGES} macro definition used for the
@code{make} command being processed.
As of @code{g77} version 0.5.23
are known to go ahead and perform various
language-specific activities when their
respective language strings do not appear
-in the @samp{LANGUAGES} macro in effect
+in the @code{LANGUAGES} macro in effect
during that invocation of @code{make}.
It is expected that these remaining problems will
be pertinent in future versions of @code{g77}.
@menu
-* Larger File Unit Numbers:: Raising @samp{MXUNIT}.
+* Larger File Unit Numbers:: Raising @code{MXUNIT}.
* Always Flush Output:: Synchronizing write errors.
* Maximum Stackable Size:: Large arrays forced off the stack.
* Floating-point Bit Patterns:: Possible programs building @code{g77}
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 @samp{MXUNIT} macro, which represents the maximum unit
+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
#define MXUNIT 100
@end example
-Change the line so that the value of @samp{MXUNIT} is defined to be
+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
-@samp{MXUNIT} set to at least 256 to avoid crashing.)
+@code{MXUNIT} set to at least 256 to avoid crashing.)
Then build or rebuild @code{g77} as appropriate.
(detection of errors might be delayed).
@code{libg2c} supports flagging write errors immediately when
-it is built with the @samp{ALWAYS_FLUSH} macro defined.
+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
of error reporting are to be compiled using the
version of @code{g77} you are building, you might wish to
modify the @code{g77} source tree so that the version of
-@code{libg2c} is built with the @samp{ALWAYS_FLUSH} macro
+@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
@cindex segmentation violation
@code{g77}, on most machines, puts many variables and arrays on the stack
where possible, and can be configured (by changing
-@samp{FFECOM_sizeMAXSTACKITEM} in @file{@value{path-g77}/com.c}) to force
+@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
@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 @samp{FFECOM_sizeMAXSTACKITEM} has no
+Also, the value of @code{FFECOM_sizeMAXSTACKITEM} has no
effect on automatic variables and arrays.
@xref{But-bugs}, for more information.
currently has a known bug requiring too much memory
and time to handle such cases.
In @file{@value{path-g77}/data.c}, the macro
-@samp{FFEDATA_sizeTOO_BIG_INIT_} is defined
+@code{FFEDATA_sizeTOO_BIG_INIT_} is defined
to the minimum size for the warning to appear.
The size is specified in storage units,
which can be bytes, words, or whatever, on a case-by-case basis.
@cindex building @code{gcc}
@cindex building @code{g77}
-@cindex @samp{LANGUAGES} macro
+@cindex @code{LANGUAGES} macro
Building @code{g77} requires building enough of @code{gcc} that
these instructions assume you're going to build all of
@code{gcc}, including @code{g++}, @code{protoize}, and so on.
You can save a little time and disk space by changes the
-@samp{LANGUAGES} macro definition in @code{gcc/Makefile.in}
+@code{LANGUAGES} macro definition in @code{gcc/Makefile.in}
or @code{gcc/Makefile}, but if you do that, you're on your own.
One change is almost @emph{certainly} going to cause failures:
-removing @samp{c} or @samp{f77} from the definition of the
-@samp{LANGUAGES} macro.
+removing @code{c} or @code{f77} from the definition of the
+@code{LANGUAGES} macro.
After configuring @code{gcc}, which configures @code{g77} and
@code{libg2c} automatically, you're ready to start the actual
As described in @ref{Installation,,Installing GNU CC,
gcc,Using and Porting GNU CC}, the values for
-the @samp{CC} and @samp{LANGUAGES} macros should
+the @code{CC} and @code{LANGUAGES} macros should
be the same as those you supplied for the build
itself.
We don't know why some non-GNU versions of @code{make} sometimes
require this alternate command, but they do.
-(Remember to supply the appropriate definition for @samp{CC}
+(Remember to supply the appropriate definition for @code{CC}
where you see @samp{@dots{}} in the above command.)
Note that using the @samp{-k} option tells @code{make} to
problem of not having the appropriate tools installed.
On UNIX systems, the simplest way to update the date-time-modified
-information of a file is to use the use the @samp{touch}
+information of a file is to use the use the @code{touch}
command.
-How to use @samp{touch} to update the derived files
+How to use @code{touch} to update the derived files
updated by each of the tools is described below.
@emph{Note:} New versions of @code{g77} might change the set of
files it generates by invoking each of these tools.
@c in the standalone derivations of this file (e.g. NEWS).
@set copyrights-news 1995-1999
-@set last-update-news 1999-04-03
+@set last-update-news 1999-04-17
@include root.texi
that has an interface that is not Year 2000 (Y2K) compliant.
Also, the @code{libg2c} has been changed to increase the likelihood
of catching references to the implementations of these intrinsics
-using the @samp{EXTERNAL} mechanism
+using the @code{EXTERNAL} mechanism
(which would avoid the new warnings).
@ifset DOC-G77
@end ifclear
@item
-@code{-fno-emulate-complex} is now the default option.
+@samp{-fno-emulate-complex} is now the default option.
This should result in improved performance
of code that uses the @code{COMPLEX} data type.
@cindex double-precision performance
@cindex -malign-double
@item
-The @code{-malign-double} option
+The @samp{-malign-double} option
now reliably aligns @emph{all} double-precision variables and arrays
on Intel x86 targets.
+@item
+Support for the @samp{-fugly} option has been removed.
+
@ifclear USERVISONLY
@item
Improve documentation and indexing,
including information on Year 2000 (Y2K) compliance.
@end ifclear
+
+@ifclear USERVISONLY
+@item
+Upgrade to @code{libf2c} as of 1999-03-17.
+@end ifclear
@end itemize
@heading In 0.5.24 and @code{egcs} 1.1.2 (versus 0.5.23 and 1.1.1):
@item
Fix the @code{IDate} intrinsic (VXT) (in @code{libg2c})
so the returned year is in the documented, non-Y2K-compliant range
-of 0--99,
+of 0-99,
instead of being returned as 100 in the year 2000.
@ifset DOC-G77
@end ifset
@item
-Fix the @samp{Date_and_Time} intrinsic (in @code{libg2c})
+Fix the @code{Date_and_Time} intrinsic (in @code{libg2c})
to return the milliseconds value properly
in @var{Values}(8).
@item
-Fix the @samp{LStat} intrinsic (in @code{libg2c})
+Fix the @code{LStat} intrinsic (in @code{libg2c})
to return device-ID information properly
in @var{SArray}(7).
@item
Fix @code{g77} so it no longer crashes compiling references
-to the @samp{Rand} intrinsic on some systems.
+to the @code{Rand} intrinsic on some systems.
@item
Fix @code{g77} portion of installation process so it works
better on some systems
(those with shells requiring @samp{else true} clauses
-on @samp{if} constructs
+on @code{if} constructs
for the completion code to be set properly).
@end itemize
@end ifclear
Fix a code-generation bug that afflicted
Intel x86 targets when @samp{-O2} was specified
compiling, for example, an old version of
-the @samp{DNRM2} routine.
+the @code{DNRM2} routine.
The x87 coprocessor stack was being
mismanaged in cases involving assigned @code{GOTO}
@itemize @bullet
@ifclear USERVISONLY
@item
-Fix bugs in the @code{libU77} intrinsic @samp{HostNm}
-that wrote one byte beyond the end of its @samp{CHARACTER}
+Fix bugs in the @code{libU77} intrinsic @code{HostNm}
+that wrote one byte beyond the end of its @code{CHARACTER}
argument,
and in the @code{libU77} intrinsics
-@samp{GMTime} and @samp{LTime}
+@code{GMTime} and @code{LTime}
that overwrote their arguments.
@end ifclear
@item
Fix @code{g77} @samp{-g} option so procedures that
-use @samp{ENTRY} can be stepped through, line by line,
+use @code{ENTRY} can be stepped through, line by line,
in @code{gdb}.
@item
@item
The upgrade to @code{libf2c} as of 1998-06-18
should fix a variety of problems, including
-those involving some uses of the @samp{T} format
+those involving some uses of the @code{T} format
specifier, and perhaps some build (porting) problems
as well.
@end ifclear
@item
@code{g77} no longer produces incorrect code
and initial values
-for @samp{EQUIVALENCE} and @samp{COMMON}
+for @code{EQUIVALENCE} and @code{COMMON}
aggregates that, due to ``unnatural'' ordering of members
vis-a-vis their types, require initial padding.
@end ifclear
This new information allows, for example,
@kbd{which __g77_length_a} to be used in @code{gdb}
to determine the type of the phantom length argument
-supplied with @samp{CHARACTER} variables.
+supplied with @code{CHARACTER} variables.
This information pertains to internally-generated
type, variable, and other information,
not to the longstanding deficiencies vis-a-vis
-@samp{COMMON} and @samp{EQUIVALENCE}.
+@code{COMMON} and @code{EQUIVALENCE}.
@item
-The F90 @samp{Date_and_Time} intrinsic now is
+The F90 @code{Date_and_Time} intrinsic now is
supported.
@item
-The F90 @samp{System_Clock} intrinsic allows
-the optional arguments (except for the @samp{Count}
+The F90 @code{System_Clock} intrinsic allows
+the optional arguments (except for the @code{Count}
argument) to be omitted.
@ifclear USERVISONLY
via @code{g77}-specific patches to the @code{gcc}
back end in previous releases include:
-@itemize --
+@itemize @minus
@item
Support for @code{__restrict__} keyword,
the options @samp{-fargument-alias}, @samp{-fargument-noalias},
@ifclear USERVISONLY
@item
-Fix bugs in the @code{libU77} intrinsic @samp{HostNm}
-that wrote one byte beyond the end of its @samp{CHARACTER}
+Fix bugs in the @code{libU77} intrinsic @code{HostNm}
+that wrote one byte beyond the end of its @code{CHARACTER}
argument,
and in the @code{libU77} intrinsics
-@samp{GMTime} and @samp{LTime}
+@code{GMTime} and @code{LTime}
that overwrote their arguments.
@end ifclear
Upgrade to @code{libf2c} as of 1998-04-20.
This should fix a variety of problems, including
-those involving some uses of the @samp{T} format
+those involving some uses of the @code{T} format
specifier, and perhaps some build (porting) problems
as well.
@end ifclear
Fix a code-generation bug that afflicted
Intel x86 targets when @samp{-O2} was specified
compiling, for example, an old version of
-the @samp{DNRM2} routine.
+the @code{DNRM2} routine.
The x87 coprocessor stack was being
mismanaged in cases involving assigned @code{GOTO}
produces a spurious @samp{I/O recursion} diagnostic at run time
when an I/O operation (such as @samp{READ *,I}) is interrupted
in a manner that causes the program to be terminated
-via the @samp{f_exit} routine (such as via @kbd{C-c}).
+via the @code{f_exit} routine (such as via @kbd{C-c}).
@end ifclear
@ifclear USERVISONLY
@item
Fix @code{g77} @samp{-g} option so procedures that
-use @samp{ENTRY} can be stepped through, line by line,
+use @code{ENTRY} can be stepped through, line by line,
in @code{gdb}.
@ifclear USERVISONLY
via @code{g77}-specific patches to the @code{gcc}
back end in previous releases include:
-@itemize --
+@itemize @minus
@item
Support for the C-language @code{restrict} keyword.
@ifclear USERVISONLY
@item
Fix compiler crashes due to using the name of a some
-non-standard intrinsics (such as @samp{FTELL} or
-@samp{FPUTC}) as such and as the name of a procedure
+non-standard intrinsics (such as @code{FTell} or
+@code{FPutC}) as such and as the name of a procedure
or common block.
Such dual use of a name in a program is allowed by
the standard.
@c
@c For example, the intrinsic @code{FPUTC} previously was
@c implemented by @code{g77} as a call to the @code{libf2c}
-@c routine @samp{fputc_}.
+@c routine @code{fputc_}.
@c This would conflict with a Fortran procedure named @code{FPUTC}
@c (using default compiler options), and this conflict
@c would cause a crash under certain circumstances.
@c
-@c Now, the intrinsic @code{FPUTC} calls @samp{G77_fputc_0},
-@c which does not conflict with the @samp{fputc_} external
+@c Now, the intrinsic @code{FPUTC} calls @code{G77_fputc_0},
+@c which does not conflict with the @code{fputc_} external
@c that implements a Fortran procedure named @code{FPUTC}.
@c
@c Programs that refer to @code{FPUTC} as an external procedure
@c without supplying their own implementation will link to
-@c the new @code{libf2c} routine @samp{fputc_}, which is
-@c simply a jacket routine that calls @samp{G77_fputc_0}.
+@c the new @code{libf2c} routine @code{fputc_}, which is
+@c simply a jacket routine that calls @code{G77_fputc_0}.
@ifclear USERVISONLY
@item
@item
Fix @code{SIGNAL} intrinsic so it accepts an
-optional third @samp{Status} argument.
+optional third @code{Status} argument.
@ifclear USERVISONLY
@item
@ifclear USERVISONLY
@item
-Fix typo in @code{make} rule @samp{g77-cross}, used only for
+Fix typo in @code{make} rule @code{g77-cross}, used only for
cross-compiling.
@end ifclear
to be names of intrinsics.
@item
-The @samp{ALWAYS_FLUSH} macro is no longer defined when
+The @code{ALWAYS_FLUSH} macro is no longer defined when
building @code{libf2c}, which should result in improved
I/O performance, especially over NFS.
@emph{Note:} If you have code that depends on the behavior
-of @code{libf2c} when built with @samp{ALWAYS_FLUSH} defined,
+of @code{libf2c} when built with @code{ALWAYS_FLUSH} defined,
you will have to modify @code{libf2c} accordingly before
building it from this and future versions of @code{g77}.
@code{LONG}, and @code{SHORT}.
@item
-A new group of intrinsics, @samp{gnu}, has been added
+A new group of intrinsics, @code{gnu}, has been added
to contain the new @code{REALPART}, @code{IMAGPART},
and @code{COMPLEX} intrinsics.
-An old group, @samp{dcp}, has been removed.
+An old group, @code{dcp}, has been removed.
@item
Complain about industry-wide ambiguous references
more, diagnostics that users are directed to pull
up automatically via a message in the diagnostic itself.
-(Hence the menu item @samp{M} for the node
-@samp{Diagnostics} in the top-level menu of
+(Hence the menu item @code{M} for the node
+@code{Diagnostics} in the top-level menu of
the Info documentation.)
@end ifclear
@end itemize
Information on previous versions is archived
in @file{@value{path-g77}/news.texi}
-following the test of the @samp{DOC-OLDNEWS} macro.
+following the test of the @code{DOC-OLDNEWS} macro.
@end ifclear
@ifset DOC-OLDNEWS
operation to a complex variable (or array element)
that also served as an input to that operation.
-The operations affected by this bug were: @samp{CONJG()},
-@samp{DCONJG()}, @samp{CCOS()}, @samp{CDCOS()},
-@samp{CLOG()}, @samp{CDLOG()}, @samp{CSIN()}, @samp{CDSIN()},
-@samp{CSQRT()}, @samp{CDSQRT()}, complex division, and
+The operations affected by this bug were: @code{CONJG()},
+@code{DCONJG()}, @code{CCOS()}, @code{CDCOS()},
+@code{CLOG()}, @code{CDLOG()}, @code{CSIN()}, @code{CDSIN()},
+@code{CSQRT()}, @code{CDSQRT()}, complex division, and
raising a @code{DOUBLE COMPLEX} operand to an @code{INTEGER}
power.
(The related generic and @samp{Z}-prefixed intrinsics,
-such as @samp{ZSIN()}, also were affected.)
+such as @code{ZSIN()}, also were affected.)
For example, @samp{C = CSQRT(C)}, @samp{Z = Z/C}, and @samp{Z = Z**I}
(where @samp{C} is @code{COMPLEX} and @samp{Z} is
@itemize @bullet
@item
Fix @code{FORMAT} statement parsing so negative values for
-specifiers such as @samp{P} (e.g. @samp{FORMAT(-1PF8.1)})
+specifiers such as @code{P} (e.g. @samp{FORMAT(-1PF8.1)})
are correctly processed as negative.
@item
@item
Modify @code{fseek_()} in @code{libf2c} to be more portable
(though, in practice, there might be no systems where this
-matters) and to catch invalid @samp{whence} arguments.
+matters) and to catch invalid @code{whence} arguments.
@item
Some useless warnings from the @samp{-Wunused} option have
@item
Abort configuration if @code{gcc} has not been patched
-using the patch file provided in the @samp{gcc/f/gbe/}
+using the patch file provided in the @file{gcc/f/gbe/}
subdirectory.
@item
@itemize @bullet
@item
@strong{Fix serious bug} in @samp{g77 -v} command that can cause removal of a
-system's @file{/dev/null} special file if run by user @samp{root}.
+system's @file{/dev/null} special file if run by user @code{root}.
@strong{All users} of version 0.5.16 should ensure that
they have not removed @file{/dev/null} or replaced it with an ordinary
@item
Make @code{libf2c} build procedures work on more systems again by
-eliminating unnecessary invocations of @samp{ld -r -x} and @samp{mv}.
+eliminating unnecessary invocations of @samp{ld -r -x} and @code{mv}.
@item
Fix omission of @samp{-funix-intrinsics-@dots{}} options in list of permitted
@item
Update @code{libf2c} to include netlib patches through 1995-08-16, and
-@code{#define} @samp{WANT_LEAD_0} to 1 to make @code{g77}-compiled code more
+@code{#define} @code{WANT_LEAD_0} to 1 to make @code{g77}-compiled code more
consistent with other Fortran implementations by outputting
leading zeros in formatted and list-directed output.
variable or array element (e.g. @samp{CALL SYSTEM('rm foo',ISTAT)}).
@item
-Add new intrinsic group named @samp{unix} to contain the new intrinsics,
+Add new intrinsic group named @code{unix} to contain the new intrinsics,
and by default enable this new group.
@item
-Move @code{LOC()} intrinsic out of the @samp{vxt} group to the new
-@samp{unix} group.
+Move @code{LOC()} intrinsic out of the @code{vxt} group to the new
+@code{unix} group.
@item
Improve @code{g77} so that @samp{g77 -v} by itself (or with
Changes to Hollerith-constant support to obey Appendix C of the
standard:
-@itemize --
+@itemize @minus
@item
Now padded on the right with zeros, not spaces.
@item
Changes and fixes to typeless-constant support:
-@itemize --
+@itemize @minus
@item
Now treated as a typeless double-length @code{INTEGER} value.
OSDN Git Service
