13.4 Names

Fortran permits each implementation to decide how to represent
names as far as how they're seen in other contexts, such as debuggers
and when interfacing to other languages, and especially as far
as how casing is handled.

External names—names of entities that are public, or “accessible”,
to all modules in a program—normally have an underscore (`_')
appended by g77,
to generate code that is compatible with 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 -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
might be intentional.

When -funderscoring is in force, any name (external or local)
that already has at least one underscore in it is
implemented by g77 by appending two underscores.
(This second underscore can be disabled via the
-fno-second-underscore option.)
External names are changed this way for f2c compatibility.
Local names are changed this way to avoid collisions with external names
that are different in the source code—f2c does the same thing, but
there's no compatibility issue there except for user expectations while
debugging.

For example:

Max_Cost = 0

Here, a user would, in the debugger, refer to this variable using the
name `max_cost__' (or `MAX_COST__' or `Max_Cost__',
as described below).
(We hope to improve g77 in this regard in the future—don't
write scripts depending on this behavior!
Also, consider experimenting with the -fno-underscoring
option to try out debugging without having to massage names by
hand like this.)

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.
Other command-line options can be specified to map names to upper
case, or to leave them exactly as written in the source file.

For example:

Foo = 9.436

Here, it is normally the case that the variable assigned will be named
`foo'.
This would be the name to enter when using a debugger to
access the variable.

However, depending on the command-line options specified, the
name implemented by g77 might instead be `FOO' or even
`Foo', thus affecting how debugging is done.

Also:

Call Foo

This would normally call a procedure that, if it were in a separate C program,
be defined starting with the line:

void foo_()

However, g77 command-line options could be used to change the casing
of names, resulting in the name `FOO_' or `Foo_' being given to the
procedure instead of `foo_', and the -fno-underscoring option
could be used to inhibit the appending of the underscore to the name.