Go to the first, previous, next, last section, table of contents.
The GNU Fortran compiler, g77, supports programs written
in the GNU Fortran language and in some other dialects of Fortran.
Some aspects of how g77 works are universal regardless
of dialect, and yet are not properly part of the GNU Fortran
language itself.
These are described below.
Note: This portion of the documentation definitely needs a lot of work!
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.
For example, some other Fortran compiler have an option (such as `-Nlx') to increase the limit on the number of continuation lines. Also, some Fortran compilation systems have an option (such as `-Nxx') to increase the limit on the number of external symbols.
g77, gcc, and GNU ld (the GNU linker) have
no equivalent options, since they do not impose arbitrary
limits in these areas.
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.
As a portable Fortran implementation,
g77 offers its users direct access to,
and otherwise depends upon,
the underlying facilities of the system
used to build g77,
the system on which g77 itself is used to compile programs,
and the system on which the 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.)
The run-time environment for a particular system inevitably imposes some limits on a program's use of various system facilities. These limits vary from system to system.
Even when such limits might be well beyond the
possibility of being encountered on a particular system,
the g77 run-time environment
has certain built-in limits,
usually, but not always, stemming from intrinsics
with inherently limited interfaces.
Currently, the g77 run-time environment
does not generally offer a less-limiting environment
by augmenting the underlying system's own environment.
Therefore, code written in the GNU Fortran language, while syntactically and semantically portable, might nevertheless make non-portable assumptions about the run-time environment--assumptions that prove to be false for some particular environments.
The GNU Fortran language,
the g77 compiler and run-time environment,
and the 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.
Not all of the limitations are described in this document. Some of the known limitations include:
Intrinsics that return values computed from system timers, whether elapsed (wall-clock) timers, process CPU timers, or other kinds of timers, are prone to experiencing wrap-around errors (or returning wrapped-around values from successive calls) due to insufficient ranges offered by the underlying system's timers.
Some of the symptoms of such behaviors include apparently negative time being computed for a duration, an extremely short amount of time being computed for a long duration, and an extremely long amount of time being computed for a short duration.
See the following for intrinsics known to have potential problems in these areas on at least some systems: section CPU_Time Intrinsic, section DTime Intrinsic (function), section DTime Intrinsic (subroutine), section ETime Intrinsic (function), section ETime Intrinsic (subroutine), section MClock Intrinsic, section MClock8 Intrinsic, section Secnds Intrinsic, section Second Intrinsic (function), section Second Intrinsic (subroutine), section System_Clock Intrinsic, section Time Intrinsic (UNIX), section Time Intrinsic (VXT), section Time8 Intrinsic.
While the g77 compiler itself is believed to
be Year-2000 (Y2K) compliant,
some intrinsics are not,
and, potentially, some underlying systems are not,
perhaps rendering some Y2K-compliant intrinsics
non-compliant when used on those particular systems.
Fortran code that uses non-Y2K-compliant intrinsics (listed below) is, itself, almost certainly not compliant, and should be modified to use Y2K-compliant intrinsics instead.
Fortran code that uses no non-Y2K-compliant intrinsics, but which currently is running on a non-Y2K-compliant system, can be made more Y2K compliant by compiling and linking it for use on a new Y2K-compliant system, such as a new version of an old, non-Y2K-compliant, system.
Currently, information on Y2K and related issues is being maintained at http://www.gnu.org/software/year2000-list.html.
See the following for intrinsics known to have potential problems in these areas on at least some systems: section Date Intrinsic, section IDate Intrinsic (VXT).
The libg2c library
shipped with any g77 that warns
about invocation of a non-Y2K-compliant intrinsic
has renamed the EXTERNAL procedure names
of those intrinsics.
This is done so that
the libg2c implementations of these intrinsics
cannot be directly linked to
as EXTERNAL names
(which normally would avoid the non-Y2K-intrinsic warning).
The renamed forms of the EXTERNAL names
of these renamed procedures
may be linked to
by appending the string `_y2kbug'
to the name of the procedure
in the source code.
For example:
CHARACTER*20 STR INTEGER YY, MM, DD EXTERNAL DATE_Y2KBUG, VXTIDATE_Y2KBUG CALL DATE_Y2KBUG (STR) CALL VXTIDATE_Y2KBUG (MM, DD, YY)
(Note that the EXTERNAL statement
is not actually required,
since the modified names are not recognized as intrinsics
by the current version of g77.
But it is shown in this specific case,
for purposes of illustration.)
The renaming of EXTERNAL procedure names of these intrinsics
causes unresolved references at link time.
For example, `EXTERNAL DATE; CALL DATE(STR)'
is normally compiled by g77
as, in C, `date_(&str, 20);'.
This, in turn, links to the date_ procedure
in the libE77 portion of libg2c,
which purposely calls a nonexistent procedure
named 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 g77 documentation.
Generally, we recommend that the EXTERNAL method
of invoking procedures in libg2c
not be used.
When used, some of the correctness checking
normally performed by g77
is skipped.
In particular, it is probably better to use the
INTRINSIC method of invoking
non-Y2K-compliant procedures,
so anyone compiling the code
can quickly notice the potential Y2K problems
(via the warnings printing by g77)
without having to even look at the code itself.
If there are problems linking libg2c
to code compiled by g77
that involve the string `y2kbug',
and these are not explained above,
that probably indicates
that a version of libg2c
older than g77
is being linked to,
or that the new library is being linked
to code compiled by an older version of g77.
That's because, as of the version that warns about
non-Y2K-compliant intrinsic invocation,
g77 references the libg2c implementations
of those intrinsics
using new names, containing the string `y2kbug'.
So, linking newly-compiled code
(invoking one of the intrinsics in question)
to an old library
might yield an unresolved reference
to G77_date_y2kbug_0.
(The old library calls it G77_date_0.)
Similarly, linking previously-compiled code
to a new library
might yield an unresolved reference
to G77_vxtidate_0.
(The new library calls it G77_vxtidate_y2kbug_0.)
The proper fix for the above problems
is to obtain the latest release of g77
and related products
(including libg2c)
and install them on all systems,
then recompile, relink, and install
(as appropriate)
all existing Fortran programs.
(Normally, this sort of renaming is steadfastly avoided.
In this case, however, it seems more important to highlight
potential Y2K problems
than to ease the transition
of potentially non-Y2K-compliant code
to new versions of g77 and libg2c.)
Currently, g77 uses the default 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 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
by most Fortran implementations.)
It is not yet clear whether this limitation never, sometimes, or always applies to the sizes of multiple-dimension arrays as a whole.
For example, on a system with 64-bit addresses
and 32-bit default INTEGER,
an array with a size greater than can be addressed
by a 32-bit offset
can be declared using multiple dimensions.
Such an array is therefore larger
than a single-dimension array can be,
on the same system.
Whether large multiple-dimension arrays are reliably supported
depends mostly on the gcc back end (code generator)
used by g77, and has not yet been fully investigated.
Currently, g77 uses the default INTEGER type
for the lengths of CHARACTER variables
and array elements.
This means that, for example,
a system with a 64-bit address space
and a 32-bit default INTEGER type
does not, under g77,
support a CHARACTER*n declaration
where n is greater than 2147483647.
Most intrinsics returning, or computing values based on, date information are prone to Year-10000 (Y10K) problems, due to supporting only 4 digits for the year.
See the following for examples: section FDate Intrinsic (function), section FDate Intrinsic (subroutine), section IDate Intrinsic (UNIX), section Time Intrinsic (VXT), section Date_and_Time Intrinsic.
Fortran implementations have a fair amount of freedom given them by the
standard as far as how much storage space is used and how much precision
and range is offered by the various types such as LOGICAL(KIND=1),
INTEGER(KIND=1), REAL(KIND=1), REAL(KIND=2),
COMPLEX(KIND=1), and CHARACTER.
Further, many compilers offer so-called `*n' notation, but
the interpretation of n varies across compilers and target architectures.
The standard requires that LOGICAL(KIND=1), INTEGER(KIND=1),
and REAL(KIND=1)
occupy the same amount of storage space, and that COMPLEX(KIND=1)
and REAL(KIND=2) take twice as much storage space as REAL(KIND=1).
Further, it requires that COMPLEX(KIND=1)
entities be ordered such that when a COMPLEX(KIND=1) variable is
storage-associated (such as via EQUIVALENCE)
with a two-element REAL(KIND=1) array named `R', `R(1)'
corresponds to the real element and `R(2)' to the imaginary
element of the COMPLEX(KIND=1) variable.
(Few requirements as to precision or ranges of any of these are
placed on the implementation, nor is the relationship of storage sizes of
these types to the CHARACTER type specified, by the standard.)
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 REAL(KIND=2)
on a boundary that is not an even multiple of its size, but still an
even multiple of the size of a REAL(KIND=1) variable.
On some target architectures, using the canonical
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 gcc and g77.
g77 warns about such
situations when it encounters them.)
g77 follows consistent rules for configuring the mapping between Fortran
types, including the `*n' notation, and the underlying architectural
types as accessed by a similarly-configured applicable version of the
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 gcc built in the same release as g77 (and
which was therefore used to build both the g77 compiler
components and the libg2c run-time library):
REAL(KIND=1)
float type.
REAL(KIND=2)
float---usually, this is a double.
INTEGER(KIND=1)
float---usually, this is either
an int or a long int.
LOGICAL(KIND=1)
gcc type as INTEGER(KIND=1).
INTEGER(KIND=2)
INTEGER(KIND=1)---usually, this is either
a long int or a long long int.
LOGICAL(KIND=2)
gcc type as INTEGER(KIND=2).
INTEGER(KIND=3)
gcc type as signed char.
LOGICAL(KIND=3)
gcc type as INTEGER(KIND=3).
INTEGER(KIND=6)
INTEGER(KIND=3)---usually, this is
a short.
LOGICAL(KIND=6)
gcc type as INTEGER(KIND=6).
COMPLEX(KIND=1)
REAL(KIND=1) scalars (one for the real part followed by
one for the imaginary part).
COMPLEX(KIND=2)
REAL(KIND=2) scalars.
numeric-type*n
CHARACTER.)
Same as whatever gcc type occupies n times the storage
space of a gcc char item.
DOUBLE PRECISION
REAL(KIND=2).
DOUBLE COMPLEX
COMPLEX(KIND=2).
Note that the above are proposed correspondences and might change
in future versions of g77---avoid writing code depending
on them.
Other types supported by g77
are derived from gcc types such as char, short,
int, long int, long long int, long double,
and so on.
That is, whatever types gcc already supports, g77 supports
now or probably will support in a future version.
The rules for the `numeric-type*n' notation
apply to these types,
and new values for `numeric-type(KIND=n)' will be
assigned in a way that encourages clarity, consistency, and portability.
g77 strictly assigns types to all constants not
documented as "typeless" (typeless constants including `'1'Z',
for example).
Many other Fortran compilers attempt to assign types to typed constants
based on their context.
This results in hard-to-find bugs, nonportable
code, and is not in the spirit (though it strictly follows the letter)
of the 77 and 90 standards.
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 g77 might differ
from how other compilers assign types to constants.
See section Context-Sensitive Constants, for more information on this issue.
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 to reduce future problems with existing code as they are implemented. Others are implemented as part of the GNU Fortran language, while yet others are provided for compatibility with other dialects of Fortran but are not part of the GNU Fortran language.
To manage these distinctions, g77 provides intrinsic groups,
a facility that is simply an extension of the intrinsic groups provided
by the GNU Fortran language.
A given specific intrinsic belongs in one or more groups. Each group is deleted, disabled, hidden, or enabled by default or a command-line option. The meaning of each term follows.
INTRINSIC statement)
are disallowed through that group.
INTRINSIC statement.
The distinction between deleting and disabling a group is illustrated by the following example. Assume intrinsic `FOO' belongs only to group `FGR'. If group `FGR' is deleted, the following program unit will successfully compile, because `FOO()' will be seen as a reference to an external function named `FOO':
PRINT *, FOO() END
If group `FGR' is disabled, compiling the above program will produce diagnostics, either because the `FOO' intrinsic is improperly invoked or, if properly invoked, it is not enabled. To change the above program so it references an external function `FOO' instead of the disabled `FOO' intrinsic, add the following line to the top:
EXTERNAL FOO
So, deleting a group tells g77 to pretend as though the intrinsics in
that group do not exist at all, whereas disabling it tells g77 to
recognize them as (disabled) intrinsics in intrinsic-like contexts.
Hiding a group is like enabling it, but the intrinsic must be first
named in an INTRINSIC statement to be considered a reference to the
intrinsic rather than to an external procedure.
This might be the "safest" way to treat a new group of intrinsics
when compiling old
code, because it allows the old code to be generally written as if
those new intrinsics never existed, but to be changed to use them
by inserting INTRINSIC statements in the appropriate places.
However, it should be the goal of development to use EXTERNAL
for all names of external procedures that might be intrinsic names.
If an intrinsic is in more than one group, it is enabled if any of its
containing groups are enabled; if not so enabled, it is hidden if
any of its containing groups are hidden; if not so hidden, it is disabled
if any of its containing groups are disabled; if not so disabled, it is
deleted.
This extra complication is necessary because some intrinsics,
such as IBITS, belong to more than one group, and hence should be
enabled if any of the groups to which they belong are enabled, and so
on.
The groups are:
badu77
gnu
f2c
f2c converter and/or libf2c.
f90
mil
MVBITS, IAND, BTEST, and so on).
unix
IARGC, EXIT, ERF, and so on).
vxt
g77 supports intrinsics other than those in the GNU Fortran
language proper.
This set of intrinsics is described below.
COMPLEX(KIND=2) value.
REAL(KIND=2).
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL ACosD' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL AIMax0' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL AIMin0' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL AJMax0' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL AJMin0' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL ASinD' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL ATan2D' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL ATanD' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL BITest' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL BJTest' to use this name for an external procedure.
CDAbs(A)
CDAbs: REAL(KIND=2) function.
A: COMPLEX(KIND=2); scalar; INTENT(IN).
Intrinsic groups: f2c, vxt.
Description:
Archaic form of ABS() that is specific
to one type for A.
See section Abs Intrinsic.
CDCos(X)
CDCos: COMPLEX(KIND=2) function.
X: COMPLEX(KIND=2); scalar; INTENT(IN).
Intrinsic groups: f2c, vxt.
Description:
Archaic form of COS() that is specific
to one type for X.
See section Cos Intrinsic.
CDExp(X)
CDExp: COMPLEX(KIND=2) function.
X: COMPLEX(KIND=2); scalar; INTENT(IN).
Intrinsic groups: f2c, vxt.
Description:
Archaic form of EXP() that is specific
to one type for X.
See section Exp Intrinsic.
CDLog(X)
CDLog: COMPLEX(KIND=2) function.
X: COMPLEX(KIND=2); scalar; INTENT(IN).
Intrinsic groups: f2c, vxt.
Description:
Archaic form of LOG() that is specific
to one type for X.
See section Log Intrinsic.
CDSin(X)
CDSin: COMPLEX(KIND=2) function.
X: COMPLEX(KIND=2); scalar; INTENT(IN).
Intrinsic groups: f2c, vxt.
Description:
Archaic form of SIN() that is specific
to one type for X.
See section Sin Intrinsic.
CDSqRt(X)
CDSqRt: COMPLEX(KIND=2) function.
X: COMPLEX(KIND=2); scalar; INTENT(IN).
Intrinsic groups: f2c, vxt.
Description:
Archaic form of SQRT() that is specific
to one type for X.
See section SqRt Intrinsic.
ChDir(Dir)
ChDir: INTEGER(KIND=1) function.
Dir: CHARACTER; scalar; INTENT(IN).
Intrinsic groups: badu77.
Description:
Sets the current working directory to be Dir.
Returns 0 on success or a non-zero error code.
See chdir(3).
Caution: Using this routine during I/O to a unit connected with a non-absolute file name can cause subsequent I/O on such a unit to fail because the I/O library might reopen files by name.
Due to the side effects performed by this intrinsic, the function form is not recommended.
For information on other intrinsics with the same name: See section ChDir Intrinsic (subroutine).
ChMod(Name, Mode)
ChMod: INTEGER(KIND=1) function.
Name: CHARACTER; scalar; INTENT(IN).
Mode: CHARACTER; scalar; INTENT(IN).
Intrinsic groups: badu77.
Description:
Changes the access mode of file Name according to the
specification Mode, which is given in the format of
chmod(1).
A null character (`CHAR(0)') marks the end of
the name in Name---otherwise,
trailing blanks in Name are ignored.
Currently, Name must not contain the single quote
character.
Returns 0 on success or a non-zero error code otherwise.
Note that this currently works
by actually invoking /bin/chmod (or the chmod found when
the library was configured) and so might fail in some circumstances and
will, anyway, be slow.
Due to the side effects performed by this intrinsic, the function form is not recommended.
For information on other intrinsics with the same name: See section ChMod Intrinsic (subroutine).
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL CosD' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL DACosD' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL DASinD' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL DATan2D' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL DATanD' to use this name for an external procedure.
CALL Date(Date)
Date: CHARACTER; scalar; INTENT(OUT).
Intrinsic groups: vxt.
Description:
Returns Date in the form `dd-mmm-yy', representing the numeric day of the month dd, a three-character abbreviation of the month name mmm and the last two digits of the year yy, e.g. `25-Nov-96'.
This intrinsic is not recommended, due to the year 2000 approaching. Therefore, programs making use of this intrinsic might not be Year 2000 (Y2K) compliant. See section CTime Intrinsic (subroutine), for information on obtaining more digits for the current (or any) date.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL DbleQ' to use this name for an external procedure.
DCmplx(X, Y)
DCmplx: COMPLEX(KIND=2) function.
X: INTEGER, REAL, or COMPLEX; scalar; INTENT(IN).
Y: INTEGER or REAL; OPTIONAL (must be omitted if X is COMPLEX); scalar; INTENT(IN).
Intrinsic groups: f2c, vxt.
Description:
If X is not type COMPLEX,
constructs a value of type COMPLEX(KIND=2) from the
real and imaginary values specified by X and
Y, respectively.
If Y is omitted, `0D0' is assumed.
If X is type COMPLEX,
converts it to type COMPLEX(KIND=2).
Although this intrinsic is not standard Fortran,
it is a popular extension offered by many compilers
that support DOUBLE COMPLEX, since it offers
the easiest way to convert to DOUBLE COMPLEX
without using Fortran 90 features (such as the `KIND='
argument to the CMPLX() intrinsic).
(`CMPLX(0D0, 0D0)' returns a single-precision
COMPLEX result, as required by standard FORTRAN 77.
That's why so many compilers provide DCMPLX(), since
`DCMPLX(0D0, 0D0)' returns a DOUBLE COMPLEX
result.
Still, DCMPLX() converts even REAL*16 arguments
to their REAL*8 equivalents in most dialects of
Fortran, so neither it nor CMPLX() allow easy
construction of arbitrary-precision values without
potentially forcing a conversion involving extending or
reducing precision.
GNU Fortran provides such an intrinsic, called COMPLEX().)
See section Complex Intrinsic, for information on easily constructing
a COMPLEX value of arbitrary precision from REAL
arguments.
DConjg(Z)
DConjg: COMPLEX(KIND=2) function.
Z: COMPLEX(KIND=2); scalar; INTENT(IN).
Intrinsic groups: f2c, vxt.
Description:
Archaic form of CONJG() that is specific
to one type for Z.
See section Conjg Intrinsic.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL DCosD' to use this name for an external procedure.
DFloat(A)
DFloat: REAL(KIND=2) function.
A: INTEGER; scalar; INTENT(IN).
Intrinsic groups: f2c, vxt.
Description:
Archaic form of REAL() that is specific
to one type for A.
See section Real Intrinsic.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL DFlotI' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL DFlotJ' to use this name for an external procedure.
DImag(Z)
DImag: REAL(KIND=2) function.
Z: COMPLEX(KIND=2); scalar; INTENT(IN).
Intrinsic groups: f2c, vxt.
Description:
Archaic form of AIMAG() that is specific
to one type for Z.
See section AImag Intrinsic.
DReal(A)
DReal: REAL(KIND=2) function.
A: INTEGER, REAL, or COMPLEX; scalar; INTENT(IN).
Intrinsic groups: vxt.
Description:
Converts A to REAL(KIND=2).
If A is type COMPLEX, its real part
is converted (if necessary) to REAL(KIND=2),
and its imaginary part is disregarded.
Although this intrinsic is not standard Fortran,
it is a popular extension offered by many compilers
that support DOUBLE COMPLEX, since it offers
the easiest way to extract the real part of a DOUBLE COMPLEX
value without using the Fortran 90 REAL() intrinsic
in a way that produces a return value inconsistent with
the way many FORTRAN 77 compilers handle REAL() of
a DOUBLE COMPLEX value.
See section RealPart Intrinsic, for information on a GNU Fortran intrinsic that avoids these areas of confusion.
See section Dble Intrinsic, for information on the standard FORTRAN 77
replacement for DREAL().
See section REAL() and AIMAG() of Complex, for more information on
this issue.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL DSinD' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL DTanD' to use this name for an external procedure.
DTime(TArray)
DTime: REAL(KIND=1) function.
TArray: REAL(KIND=1); DIMENSION(2); INTENT(OUT).
Intrinsic groups: badu77.
Description:
Initially, return the number of seconds of runtime since the start of the process's execution as the function value, and the user and system components of this in `TArray(1)' and `TArray(2)' respectively. The functions' value is equal to `TArray(1) + TArray(2)'.
Subsequent invocations of `DTIME()' return values accumulated since the previous invocation.
On some systems, the underlying timings are represented using types with sufficiently small limits that overflows (wraparounds) are possible, such as 32-bit types. Therefore, the values returned by this intrinsic might be, or become, negative, or numerically less than previous values, during a single run of the compiled program.
Due to the side effects performed by this intrinsic, the function form is not recommended.
For information on other intrinsics with the same name: See section DTime Intrinsic (subroutine).
FGet(C)
FGet: INTEGER(KIND=1) function.
C: CHARACTER; scalar; INTENT(OUT).
Intrinsic groups: badu77.
Description:
Reads a single character into C in stream mode from unit 5
(by-passing normal formatted input) using getc(3).
Returns 0 on
success, -1 on end-of-file, and the error code from
ferror(3) otherwise.
Stream I/O should not be mixed with normal record-oriented (formatted or unformatted) I/O on the same unit; the results are unpredictable.
For information on other intrinsics with the same name: See section FGet Intrinsic (subroutine).
FGetC(Unit, C)
FGetC: INTEGER(KIND=1) function.
Unit: INTEGER; scalar; INTENT(IN).
C: CHARACTER; scalar; INTENT(OUT).
Intrinsic groups: badu77.
Description:
Reads a single character into C in stream mode from unit Unit
(by-passing normal formatted output) using getc(3).
Returns 0 on
success, -1 on end-of-file, and the error code from
ferror(3) otherwise.
Stream I/O should not be mixed with normal record-oriented (formatted or unformatted) I/O on the same unit; the results are unpredictable.
For information on other intrinsics with the same name: See section FGetC Intrinsic (subroutine).
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL FloatI' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL FloatJ' to use this name for an external procedure.
FPut(C)
FPut: INTEGER(KIND=1) function.
C: CHARACTER; scalar; INTENT(IN).
Intrinsic groups: badu77.
Description:
Writes the single character C in stream mode to unit 6
(by-passing normal formatted output) using getc(3).
Returns 0 on
success, the error code from ferror(3) otherwise.
Stream I/O should not be mixed with normal record-oriented (formatted or unformatted) I/O on the same unit; the results are unpredictable.
For information on other intrinsics with the same name: See section FPut Intrinsic (subroutine).
FPutC(Unit, C)
FPutC: INTEGER(KIND=1) function.
Unit: INTEGER; scalar; INTENT(IN).
C: CHARACTER; scalar; INTENT(IN).
Intrinsic groups: badu77.
Description:
Writes the single character C in stream mode to unit Unit
(by-passing normal formatted output) using putc(3).
Returns 0 on
success, the error code from ferror(3) otherwise.
Stream I/O should not be mixed with normal record-oriented (formatted or unformatted) I/O on the same unit; the results are unpredictable.
For information on other intrinsics with the same name: See section FPutC Intrinsic (subroutine).
CALL IDate(M, D, Y)
M: INTEGER(KIND=1); scalar; INTENT(OUT).
D: INTEGER(KIND=1); scalar; INTENT(OUT).
Y: INTEGER(KIND=1); scalar; INTENT(OUT).
Intrinsic groups: vxt.
Description:
Returns the numerical values of the current local time. The month (in the range 1--12) is returned in M, the day (in the range 1--7) in D, and the year in Y (in the range 0--99).
This intrinsic is not recommended, due to the year 2000 approaching. Therefore, programs making use of this intrinsic might not be Year 2000 (Y2K) compliant. For example, the date might appear, to such programs, to wrap around (change from a larger value to a smaller one) as of the Year 2000.
See section IDate Intrinsic (UNIX), for information on obtaining more digits for the current date.
For information on other intrinsics with the same name: See section IDate Intrinsic (UNIX).
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IIAbs' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IIAnd' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IIBClr' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IIBits' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IIBSet' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IIDiM' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IIDInt' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IIDNnt' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IIEOr' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IIFix' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IInt' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IIOr' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IIQint' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IIQNnt' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IIShftC' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IISign' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IMax0' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IMax1' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IMin0' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IMin1' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IMod' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL INInt' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL INot' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL IZExt' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JIAbs' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JIAnd' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JIBClr' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JIBits' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JIBSet' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JIDiM' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JIDInt' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JIDNnt' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JIEOr' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JIFix' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JInt' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JIOr' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JIQint' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JIQNnt' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JIShft' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JIShftC' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JISign' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JMax0' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JMax1' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JMin0' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JMin1' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JMod' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JNInt' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JNot' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL JZExt' to use this name for an external procedure.
Kill(Pid, Signal)
Kill: INTEGER(KIND=1) function.
Pid: INTEGER; scalar; INTENT(IN).
Signal: INTEGER; scalar; INTENT(IN).
Intrinsic groups: badu77.
Description:
Sends the signal specified by Signal to the process Pid.
Returns 0 on success or a non-zero error code.
See kill(2).
Due to the side effects performed by this intrinsic, the function form is not recommended.
For information on other intrinsics with the same name: See section Kill Intrinsic (subroutine).
Link(Path1, Path2)
Link: INTEGER(KIND=1) function.
Path1: CHARACTER; scalar; INTENT(IN).
Path2: CHARACTER; scalar; INTENT(IN).
Intrinsic groups: badu77.
Description:
Makes a (hard) link from file Path1 to Path2.
A null character (`CHAR(0)') marks the end of
the names in Path1 and Path2---otherwise,
trailing blanks in Path1 and Path2 are ignored.
Returns 0 on success or a non-zero error code.
See link(2).
Due to the side effects performed by this intrinsic, the function form is not recommended.
For information on other intrinsics with the same name: See section Link Intrinsic (subroutine).
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QAbs' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QACos' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QACosD' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QASin' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QASinD' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QATan' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QATan2' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QATan2D' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QATanD' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QCos' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QCosD' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QCosH' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QDiM' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QExp' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QExt' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QExtD' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QFloat' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QInt' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QLog' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QLog10' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QMax1' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QMin1' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QMod' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QNInt' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QSin' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QSinD' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QSinH' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QSqRt' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QTan' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QTanD' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL QTanH' to use this name for an external procedure.
Rename(Path1, Path2)
Rename: INTEGER(KIND=1) function.
Path1: CHARACTER; scalar; INTENT(IN).
Path2: CHARACTER; scalar; INTENT(IN).
Intrinsic groups: badu77.
Description:
Renames the file Path1 to Path2.
A null character (`CHAR(0)') marks the end of
the names in Path1 and Path2---otherwise,
trailing blanks in Path1 and Path2 are ignored.
See rename(2).
Returns 0 on success or a non-zero error code.
Due to the side effects performed by this intrinsic, the function form is not recommended.
For information on other intrinsics with the same name: See section Rename Intrinsic (subroutine).
Secnds(T)
Secnds: REAL(KIND=1) function.
T: REAL(KIND=1); scalar; INTENT(IN).
Intrinsic groups: vxt.
Description:
Returns the local time in seconds since midnight minus the value T.
This values returned by this intrinsic become numerically less than previous values (they wrap around) during a single run of the compiler program, under normal circumstances (such as running through the midnight hour).
Signal(Number, Handler)
Signal: INTEGER(KIND=7) function.
Number: INTEGER; scalar; INTENT(IN).
Handler: Signal handler (INTEGER FUNCTION or SUBROUTINE)
or dummy/global INTEGER(KIND=1) scalar.
Intrinsic groups: badu77.
Description:
If Handler is a an EXTERNAL routine, arranges for it to be
invoked with a single integer argument (of system-dependent length)
when signal Number occurs.
If Handler is an integer, it can be
used to turn off handling of signal Number or revert to its default
action.
See signal(2).
Note that Handler will be called using C conventions,
so the value of its argument in Fortran terms
is obtained by applying %LOC() (or LOC()) to it.
The value returned by signal(2) is returned.
Due to the side effects performed by this intrinsic, the function form is not recommended.
Warning: If the returned value is stored in
an INTEGER(KIND=1) (default INTEGER) argument,
truncation of the original return value occurs on some systems
(such as Alphas, which have 64-bit pointers but 32-bit default integers),
with no warning issued by g77 under normal circumstances.
Therefore, the following code fragment might silently fail on some systems:
INTEGER RTN EXTERNAL MYHNDL RTN = SIGNAL(signum, MYHNDL) ... ! Restore original handler: RTN = SIGNAL(signum, RTN)
The reason for the failure is that `RTN' might not hold all the information on the original handler for the signal, thus restoring an invalid handler. This bug could manifest itself as a spurious run-time failure at an arbitrary point later during the program's execution, for example.
Warning: Use of the libf2c run-time library function
`signal_' directly
(such as via `EXTERNAL SIGNAL')
requires use of the %VAL() construct
to pass an INTEGER value
(such as `SIG_IGN' or `SIG_DFL')
for the Handler argument.
However, while `RTN = SIGNAL(signum, %VAL(SIG_IGN))'
works when `SIGNAL' is treated as an external procedure
(and resolves, at link time, to libf2c's `signal_' routine),
this construct is not valid when `SIGNAL' is recognized
as the intrinsic of that name.
Therefore, for maximum portability and reliability, code such references to the `SIGNAL' facility as follows:
INTRINSIC SIGNAL ... RTN = SIGNAL(signum, SIG_IGN)
g77 will compile such a call correctly,
while other compilers will generally either do so as well
or reject the `INTRINSIC SIGNAL' statement via a diagnostic,
allowing you to take appropriate action.
For information on other intrinsics with the same name: See section Signal Intrinsic (subroutine).
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL SinD' to use this name for an external procedure.
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL SnglQ' to use this name for an external procedure.
SymLnk(Path1, Path2)
SymLnk: INTEGER(KIND=1) function.
Path1: CHARACTER; scalar; INTENT(IN).
Path2: CHARACTER; scalar; INTENT(IN).
Intrinsic groups: badu77.
Description:
Makes a symbolic link from file Path1 to Path2.
A null character (`CHAR(0)') marks the end of
the names in Path1 and Path2---otherwise,
trailing blanks in Path1 and Path2 are ignored.
Returns 0 on success or a non-zero error code
(ENOSYS if the system does not provide symlink(2)).
Due to the side effects performed by this intrinsic, the function form is not recommended.
For information on other intrinsics with the same name: See section SymLnk Intrinsic (subroutine).
System(Command)
System: INTEGER(KIND=1) function.
Command: CHARACTER; scalar; INTENT(IN).
Intrinsic groups: badu77.
Description:
Passes the command Command to a shell (see system(3)).
Returns the value returned by
system(3), presumably 0 if the shell command succeeded.
Note that which shell is used to invoke the command is system-dependent
and environment-dependent.
Due to the side effects performed by this intrinsic, the function form is not recommended. However, the function form can be valid in cases where the actual side effects performed by the call are unimportant to the application.
For example, on a UNIX system, `SAME = SYSTEM('cmp a b')'
does not perform any side effects likely to be important to the
program, so the programmer would not care if the actual system
call (and invocation of cmp) was optimized away in a situation
where the return value could be determined otherwise, or was not
actually needed (`SAME' not actually referenced after the
sample assignment statement).
For information on other intrinsics with the same name: See section System Intrinsic (subroutine).
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL TanD' to use this name for an external procedure.
CALL Time(Time)
Time: CHARACTER*8; scalar; INTENT(OUT).
Intrinsic groups: vxt.
Description:
Returns in Time a character representation of the current time as
obtained from ctime(3).
Programs making use of this intrinsic might not be Year 10000 (Y10K) compliant. For example, the date might appear, to such programs, to wrap around (change from a larger value to a smaller one) as of the Year 10000.
See section FDate Intrinsic (subroutine), for an equivalent routine.
For information on other intrinsics with the same name: See section Time Intrinsic (UNIX).
UMask(Mask)
UMask: INTEGER(KIND=1) function.
Mask: INTEGER; scalar; INTENT(IN).
Intrinsic groups: badu77.
Description:
Sets the file creation mask to Mask and returns the old value.
See umask(2).
Due to the side effects performed by this intrinsic, the function form is not recommended.
For information on other intrinsics with the same name: See section UMask Intrinsic (subroutine).
Unlink(File)
Unlink: INTEGER(KIND=1) function.
File: CHARACTER; scalar; INTENT(IN).
Intrinsic groups: badu77.
Description:
Unlink the file File.
A null character (`CHAR(0)') marks the end of
the name in File---otherwise,
trailing blanks in File are ignored.
Returns 0 on success or a non-zero error code.
See unlink(2).
Due to the side effects performed by this intrinsic, the function form is not recommended.
For information on other intrinsics with the same name: See section Unlink Intrinsic (subroutine).
This intrinsic is not yet implemented. The name is, however, reserved as an intrinsic. Use `EXTERNAL ZExt' to use this name for an external procedure.
Go to the first, previous, next, last section, table of contents.