12. The GNU Fortran Compiler

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!

12.1 Compiler Limits
12.2 Run-time Environment Limits
12.3 Compiler Types
12.4 Compiler Constants
12.5 Compiler Intrinsics

12.1 Compiler Limits

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.

12.2 Run-time Environment Limits

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:

12.2.1 Timer Wraparounds
12.2.2 Year 2000 (Y2K) Problems
12.2.3 Array Size
12.2.4 Character-variable Length
12.2.5 Year 10000 (Y10K) Problems

12.2.1 Timer Wraparounds

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: 10.11.9.49 CPU_Time Intrinsic, 12.5.2.36 DTime Intrinsic (function), 10.11.9.91 DTime Intrinsic (subroutine), 10.11.9.97 ETime Intrinsic (function), 10.11.9.96 ETime Intrinsic (subroutine), 10.11.9.185 MClock Intrinsic, 10.11.9.186 MClock8 Intrinsic, 12.5.2.127 Secnds Intrinsic, 10.11.9.220 Second Intrinsic (function), 10.11.9.221 Second Intrinsic (subroutine), 10.11.9.242 System_Clock Intrinsic, 10.11.9.245 Time Intrinsic (UNIX), 12.5.2.134 Time Intrinsic (VXT), 10.11.9.246 Time8 Intrinsic.

12.2.2 Year 2000 (Y2K) Problems

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: 12.5.2.24 Date Intrinsic, 12.5.2.43 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.)

12.2.3 Array Size

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.

12.2.4 Character-variable Length

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.

12.2.5 Year 10000 (Y10K) Problems

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: 10.11.9.102 FDate Intrinsic (function), 10.11.9.101 FDate Intrinsic (subroutine), 10.11.9.138 IDate Intrinsic (UNIX), 12.5.2.134 Time Intrinsic (VXT), 10.11.9.60 Date_and_Time Intrinsic.

12.3 Compiler Types

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)

Same as float type.

REAL(KIND=2)

Same as whatever floating-point type that is twice the size of a float---usually, this is a double.

INTEGER(KIND=1)

Same as an integral type that is occupies the same amount of memory storage as float---usually, this is either an int or a long int.

LOGICAL(KIND=1)

Same gcc type as INTEGER(KIND=1).

INTEGER(KIND=2)

Twice the size, and usually nearly twice the range, as INTEGER(KIND=1)---usually, this is either a long int or a long long int.

LOGICAL(KIND=2)

Same gcc type as INTEGER(KIND=2).

INTEGER(KIND=3)

Same gcc type as signed char.

LOGICAL(KIND=3)

Same gcc type as INTEGER(KIND=3).

INTEGER(KIND=6)

Twice the size, and usually nearly twice the range, as INTEGER(KIND=3)---usually, this is a short.

LOGICAL(KIND=6)

Same gcc type as INTEGER(KIND=6).

COMPLEX(KIND=1)

Two REAL(KIND=1) scalars (one for the real part followed by one for the imaginary part).

COMPLEX(KIND=2)

Two REAL(KIND=2) scalars.

numeric-type*n

(Where numeric-type is any type other than CHARACTER.) Same as whatever gcc type occupies n times the storage space of a gcc char item.

DOUBLE PRECISION

Same as REAL(KIND=2).

DOUBLE COMPLEX

Same as 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.

12.4 Compiler Constants

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 18.5.4 Context-Sensitive Constants, for more information on this issue.

12.5 Compiler Intrinsics

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.

12.5.1 Intrinsic Groups		How intrinsics are grouped for easy management.
12.5.2 Other Intrinsics		Intrinsics other than those in the GNU Fortran language.

12.5.1 Intrinsic Groups

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.

Deleted

No intrinsics are recognized as belonging to that group.

Disabled

Intrinsics are recognized as belonging to the group, but references to them (other than via the INTRINSIC statement) are disallowed through that group.

Hidden

Intrinsics in that group are recognized and enabled (if implemented) only if the first mention of the actual name of an intrinsic in a program unit is in an INTRINSIC statement.

Enabled

Intrinsics in that group are recognized and enabled (if implemented).

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

UNIX intrinsics having inappropriate forms (usually functions that have intended side effects).

gnu

Intrinsics the GNU Fortran language supports that are extensions to the Fortran standards (77 and 90).

f2c

Intrinsics supported by AT&T's f2c converter and/or libf2c.

f90

Fortran 90 intrinsics.

mil

MIL-STD 1753 intrinsics (MVBITS, IAND, BTEST, and so on).

unix

UNIX intrinsics (IARGC, EXIT, ERF, and so on).

vxt

VAX/VMS FORTRAN (current as of v4) intrinsics.

12.5.2 Other Intrinsics

g77 supports intrinsics other than those in the GNU Fortran language proper. This set of intrinsics is described below.

(Note that the empty lines appearing in the menu below are not intentional--they result from a bug in the makeinfo program.)

12.5.2.1 ACosD Intrinsic		(Reserved for future use.)
12.5.2.2 AIMax0 Intrinsic		(Reserved for future use.)
12.5.2.3 AIMin0 Intrinsic		(Reserved for future use.)
12.5.2.4 AJMax0 Intrinsic		(Reserved for future use.)
12.5.2.5 AJMin0 Intrinsic		(Reserved for future use.)
12.5.2.6 ASinD Intrinsic		(Reserved for future use.)
12.5.2.7 ATan2D Intrinsic		(Reserved for future use.)
12.5.2.8 ATanD Intrinsic		(Reserved for future use.)
12.5.2.9 BITest Intrinsic		(Reserved for future use.)
12.5.2.10 BJTest Intrinsic		(Reserved for future use.)
12.5.2.11 CDAbs Intrinsic		Absolute value (archaic).
12.5.2.12 CDCos Intrinsic		Cosine (archaic).
12.5.2.13 CDExp Intrinsic		Exponential (archaic).
12.5.2.14 CDLog Intrinsic		Natural logarithm (archaic).
12.5.2.15 CDSin Intrinsic		Sine (archaic).
12.5.2.16 CDSqRt Intrinsic		Square root (archaic).
12.5.2.17 ChDir Intrinsic (function)		Change directory.
12.5.2.18 ChMod Intrinsic (function)		Change file modes.
12.5.2.19 CosD Intrinsic		(Reserved for future use.)
12.5.2.20 DACosD Intrinsic		(Reserved for future use.)
12.5.2.21 DASinD Intrinsic		(Reserved for future use.)
12.5.2.22 DATan2D Intrinsic		(Reserved for future use.)
12.5.2.23 DATanD Intrinsic		(Reserved for future use.)
12.5.2.24 Date Intrinsic		Get current date as dd-Mon-yy.
12.5.2.25 DbleQ Intrinsic		(Reserved for future use.)
12.5.2.26 DCmplx Intrinsic		Construct COMPLEX(KIND=2) value.
12.5.2.27 DConjg Intrinsic		Complex conjugate (archaic).
12.5.2.28 DCosD Intrinsic		(Reserved for future use.)
12.5.2.29 DFloat Intrinsic		Conversion (archaic).
12.5.2.30 DFlotI Intrinsic		(Reserved for future use.)
12.5.2.31 DFlotJ Intrinsic		(Reserved for future use.)
12.5.2.32 DImag Intrinsic		Convert/extract imaginary part of complex (archaic).
12.5.2.33 DReal Intrinsic		Convert value to type REAL(KIND=2).
12.5.2.34 DSinD Intrinsic		(Reserved for future use.)
12.5.2.35 DTanD Intrinsic		(Reserved for future use.)
12.5.2.36 DTime Intrinsic (function)		Get elapsed time since last time.
12.5.2.37 FGet Intrinsic (function)		Read a character from unit 5 stream-wise.
12.5.2.38 FGetC Intrinsic (function)		Read a character stream-wise.
12.5.2.39 FloatI Intrinsic		(Reserved for future use.)
12.5.2.40 FloatJ Intrinsic		(Reserved for future use.)
12.5.2.41 FPut Intrinsic (function)		Write a character to unit 6 stream-wise.
12.5.2.42 FPutC Intrinsic (function)		Write a character stream-wise.
12.5.2.43 IDate Intrinsic (VXT)		Get local time info (VAX/VMS).
12.5.2.44 IIAbs Intrinsic		(Reserved for future use.)
12.5.2.45 IIAnd Intrinsic		(Reserved for future use.)
12.5.2.46 IIBClr Intrinsic		(Reserved for future use.)
12.5.2.47 IIBits Intrinsic		(Reserved for future use.)
12.5.2.48 IIBSet Intrinsic		(Reserved for future use.)
12.5.2.49 IIDiM Intrinsic		(Reserved for future use.)
12.5.2.50 IIDInt Intrinsic		(Reserved for future use.)
12.5.2.51 IIDNnt Intrinsic		(Reserved for future use.)
12.5.2.52 IIEOr Intrinsic		(Reserved for future use.)
12.5.2.53 IIFix Intrinsic		(Reserved for future use.)
12.5.2.54 IInt Intrinsic		(Reserved for future use.)
12.5.2.55 IIOr Intrinsic		(Reserved for future use.)
12.5.2.56 IIQint Intrinsic		(Reserved for future use.)
12.5.2.57 IIQNnt Intrinsic		(Reserved for future use.)
12.5.2.58 IIShftC Intrinsic		(Reserved for future use.)
12.5.2.59 IISign Intrinsic		(Reserved for future use.)
12.5.2.60 IMax0 Intrinsic		(Reserved for future use.)
12.5.2.61 IMax1 Intrinsic		(Reserved for future use.)
12.5.2.62 IMin0 Intrinsic		(Reserved for future use.)
12.5.2.63 IMin1 Intrinsic		(Reserved for future use.)
12.5.2.64 IMod Intrinsic		(Reserved for future use.)
12.5.2.65 INInt Intrinsic		(Reserved for future use.)
12.5.2.66 INot Intrinsic		(Reserved for future use.)
12.5.2.67 IZExt Intrinsic		(Reserved for future use.)
12.5.2.68 JIAbs Intrinsic		(Reserved for future use.)
12.5.2.69 JIAnd Intrinsic		(Reserved for future use.)
12.5.2.70 JIBClr Intrinsic		(Reserved for future use.)
12.5.2.71 JIBits Intrinsic		(Reserved for future use.)
12.5.2.72 JIBSet Intrinsic		(Reserved for future use.)
12.5.2.73 JIDiM Intrinsic		(Reserved for future use.)
12.5.2.74 JIDInt Intrinsic		(Reserved for future use.)
12.5.2.75 JIDNnt Intrinsic		(Reserved for future use.)
12.5.2.76 JIEOr Intrinsic		(Reserved for future use.)
12.5.2.77 JIFix Intrinsic		(Reserved for future use.)
12.5.2.78 JInt Intrinsic		(Reserved for future use.)
12.5.2.79 JIOr Intrinsic		(Reserved for future use.)
12.5.2.80 JIQint Intrinsic		(Reserved for future use.)
12.5.2.81 JIQNnt Intrinsic		(Reserved for future use.)
12.5.2.82 JIShft Intrinsic		(Reserved for future use.)
12.5.2.83 JIShftC Intrinsic		(Reserved for future use.)
12.5.2.84 JISign Intrinsic		(Reserved for future use.)
12.5.2.85 JMax0 Intrinsic		(Reserved for future use.)
12.5.2.86 JMax1 Intrinsic		(Reserved for future use.)
12.5.2.87 JMin0 Intrinsic		(Reserved for future use.)
12.5.2.88 JMin1 Intrinsic		(Reserved for future use.)
12.5.2.89 JMod Intrinsic		(Reserved for future use.)
12.5.2.90 JNInt Intrinsic		(Reserved for future use.)
12.5.2.91 JNot Intrinsic		(Reserved for future use.)
12.5.2.92 JZExt Intrinsic		(Reserved for future use.)
12.5.2.93 Kill Intrinsic (function)		Signal a process.
12.5.2.94 Link Intrinsic (function)		Make hard link in file system.
12.5.2.95 QAbs Intrinsic		(Reserved for future use.)
12.5.2.96 QACos Intrinsic		(Reserved for future use.)
12.5.2.97 QACosD Intrinsic		(Reserved for future use.)
12.5.2.98 QASin Intrinsic		(Reserved for future use.)
12.5.2.99 QASinD Intrinsic		(Reserved for future use.)
12.5.2.100 QATan Intrinsic		(Reserved for future use.)
12.5.2.101 QATan2 Intrinsic		(Reserved for future use.)
12.5.2.102 QATan2D Intrinsic		(Reserved for future use.)
12.5.2.103 QATanD Intrinsic		(Reserved for future use.)
12.5.2.104 QCos Intrinsic		(Reserved for future use.)
12.5.2.105 QCosD Intrinsic		(Reserved for future use.)
12.5.2.106 QCosH Intrinsic		(Reserved for future use.)
12.5.2.107 QDiM Intrinsic		(Reserved for future use.)
12.5.2.108 QExp Intrinsic		(Reserved for future use.)
12.5.2.109 QExt Intrinsic		(Reserved for future use.)
12.5.2.110 QExtD Intrinsic		(Reserved for future use.)
12.5.2.111 QFloat Intrinsic		(Reserved for future use.)
12.5.2.112 QInt Intrinsic		(Reserved for future use.)
12.5.2.113 QLog Intrinsic		(Reserved for future use.)
12.5.2.114 QLog10 Intrinsic		(Reserved for future use.)
12.5.2.115 QMax1 Intrinsic		(Reserved for future use.)
12.5.2.116 QMin1 Intrinsic		(Reserved for future use.)
12.5.2.117 QMod Intrinsic		(Reserved for future use.)
12.5.2.118 QNInt Intrinsic		(Reserved for future use.)
12.5.2.119 QSin Intrinsic		(Reserved for future use.)
12.5.2.120 QSinD Intrinsic		(Reserved for future use.)
12.5.2.121 QSinH Intrinsic		(Reserved for future use.)
12.5.2.122 QSqRt Intrinsic		(Reserved for future use.)
12.5.2.123 QTan Intrinsic		(Reserved for future use.)
12.5.2.124 QTanD Intrinsic		(Reserved for future use.)
12.5.2.125 QTanH Intrinsic		(Reserved for future use.)
12.5.2.126 Rename Intrinsic (function)		Rename file.
12.5.2.127 Secnds Intrinsic		Get local time offset since midnight.
12.5.2.128 Signal Intrinsic (function)		Muck with signal handling.
12.5.2.129 SinD Intrinsic		(Reserved for future use.)
12.5.2.130 SnglQ Intrinsic		(Reserved for future use.)
12.5.2.131 SymLnk Intrinsic (function)		Make symbolic link in file system.
12.5.2.132 System Intrinsic (function)		Invoke shell (system) command.
12.5.2.133 TanD Intrinsic		(Reserved for future use.)
12.5.2.134 Time Intrinsic (VXT)		Get the time as a character value.
12.5.2.135 UMask Intrinsic (function)		Set file creation permissions mask.
12.5.2.136 Unlink Intrinsic (function)		Unlink file.
12.5.2.137 ZExt Intrinsic		(Reserved for future use.)

12.5.2.1 ACosD Intrinsic

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.

12.5.2.2 AIMax0 Intrinsic

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.

12.5.2.3 AIMin0 Intrinsic

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.

12.5.2.4 AJMax0 Intrinsic

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.

12.5.2.5 AJMin0 Intrinsic

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.

12.5.2.6 ASinD Intrinsic

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.

12.5.2.7 ATan2D Intrinsic

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.

12.5.2.8 ATanD Intrinsic

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.

12.5.2.9 BITest Intrinsic

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.

12.5.2.10 BJTest Intrinsic

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.

12.5.2.11 CDAbs Intrinsic

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 10.11.9.2 Abs Intrinsic.

12.5.2.12 CDCos 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 10.11.9.46 Cos Intrinsic.

12.5.2.13 CDExp 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 10.11.9.99 Exp Intrinsic.

12.5.2.14 CDLog 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 10.11.9.170 Log Intrinsic.

12.5.2.15 CDSin 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 10.11.9.229 Sin Intrinsic.

12.5.2.16 CDSqRt 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 10.11.9.235 SqRt Intrinsic.

12.5.2.17 ChDir Intrinsic (function)

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 10.11.9.40 ChDir Intrinsic (subroutine).

12.5.2.18 ChMod Intrinsic (function)

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 10.11.9.41 ChMod Intrinsic (subroutine).

12.5.2.19 CosD Intrinsic

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.

12.5.2.20 DACosD Intrinsic

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.

12.5.2.21 DASinD Intrinsic

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.

12.5.2.22 DATan2D Intrinsic

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.

12.5.2.23 DATanD Intrinsic

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.

12.5.2.24 Date Intrinsic

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 10.11.9.53 CTime Intrinsic (subroutine), for information on obtaining more digits for the current (or any) date.

12.5.2.25 DbleQ Intrinsic

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.

12.5.2.26 DCmplx Intrinsic

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 10.11.9.44 Complex Intrinsic, for information on easily constructing a COMPLEX value of arbitrary precision from REAL arguments.

12.5.2.27 DConjg Intrinsic

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 10.11.9.45 Conjg Intrinsic.

12.5.2.28 DCosD 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.

12.5.2.29 DFloat Intrinsic

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 10.11.9.211 Real Intrinsic.

12.5.2.30 DFlotI 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.

12.5.2.31 DFlotJ Intrinsic

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.

12.5.2.32 DImag Intrinsic

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 10.11.9.8 AImag Intrinsic.

12.5.2.33 DReal 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 10.11.9.212 RealPart Intrinsic, for information on a GNU Fortran intrinsic that avoids these areas of confusion.

See section 10.11.9.67 Dble Intrinsic, for information on the standard FORTRAN 77 replacement for DREAL().

See section 10.11.5 REAL() and AIMAG() of Complex, for more information on this issue.

12.5.2.34 DSinD Intrinsic

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.

12.5.2.35 DTanD Intrinsic

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.

12.5.2.36 DTime Intrinsic (function)

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 10.11.9.91 DTime Intrinsic (subroutine).

12.5.2.37 FGet Intrinsic (function)

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 10.11.9.103 FGet Intrinsic (subroutine).

12.5.2.38 FGetC Intrinsic (function)

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 10.11.9.104 FGetC Intrinsic (subroutine).

12.5.2.39 FloatI Intrinsic

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.

12.5.2.40 FloatJ Intrinsic

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.

12.5.2.41 FPut Intrinsic (function)

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 10.11.9.109 FPut Intrinsic (subroutine).

12.5.2.42 FPutC Intrinsic (function)

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 10.11.9.110 FPutC Intrinsic (subroutine).

12.5.2.43 IDate Intrinsic (VXT)

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 10.11.9.138 IDate Intrinsic (UNIX), for information on obtaining more digits for the current date.

For information on other intrinsics with the same name: See section 10.11.9.138 IDate Intrinsic (UNIX).

12.5.2.44 IIAbs Intrinsic

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.

12.5.2.45 IIAnd Intrinsic

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.

12.5.2.46 IIBClr Intrinsic

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.

12.5.2.47 IIBits Intrinsic

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.

12.5.2.48 IIBSet Intrinsic

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.

12.5.2.49 IIDiM Intrinsic

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.

12.5.2.50 IIDInt Intrinsic

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.

12.5.2.51 IIDNnt Intrinsic

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.

12.5.2.52 IIEOr Intrinsic

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.

12.5.2.53 IIFix Intrinsic

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.

12.5.2.54 IInt Intrinsic

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.

12.5.2.55 IIOr Intrinsic

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.

12.5.2.56 IIQint Intrinsic

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.

12.5.2.57 IIQNnt Intrinsic

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.

12.5.2.58 IIShftC Intrinsic

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.

12.5.2.59 IISign Intrinsic

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.

12.5.2.60 IMax0 Intrinsic

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.

12.5.2.61 IMax1 Intrinsic

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.

12.5.2.62 IMin0 Intrinsic

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.

12.5.2.63 IMin1 Intrinsic

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.

12.5.2.64 IMod Intrinsic

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.

12.5.2.65 INInt Intrinsic

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.

12.5.2.66 INot Intrinsic

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.

12.5.2.67 IZExt Intrinsic

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.

12.5.2.68 JIAbs Intrinsic

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.

12.5.2.69 JIAnd Intrinsic

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.

12.5.2.70 JIBClr Intrinsic

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.

12.5.2.71 JIBits Intrinsic

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.

12.5.2.72 JIBSet Intrinsic

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.

12.5.2.73 JIDiM Intrinsic

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.

12.5.2.74 JIDInt Intrinsic

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.

12.5.2.75 JIDNnt Intrinsic

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.

12.5.2.76 JIEOr Intrinsic

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.

12.5.2.77 JIFix Intrinsic

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.

12.5.2.78 JInt Intrinsic

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.

12.5.2.79 JIOr Intrinsic

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.

12.5.2.80 JIQint Intrinsic

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.

12.5.2.81 JIQNnt Intrinsic

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.

12.5.2.82 JIShft Intrinsic

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.

12.5.2.83 JIShftC Intrinsic

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.

12.5.2.84 JISign Intrinsic

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.

12.5.2.85 JMax0 Intrinsic

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.

12.5.2.86 JMax1 Intrinsic

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.

12.5.2.87 JMin0 Intrinsic

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.

12.5.2.88 JMin1 Intrinsic

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.

12.5.2.89 JMod Intrinsic

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.

12.5.2.90 JNInt Intrinsic

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.

12.5.2.91 JNot Intrinsic

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.

12.5.2.92 JZExt Intrinsic

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.

12.5.2.93 Kill Intrinsic (function)

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 10.11.9.158 Kill Intrinsic (subroutine).

12.5.2.94 Link Intrinsic (function)

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 10.11.9.165 Link Intrinsic (subroutine).

12.5.2.95 QAbs Intrinsic

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.

12.5.2.96 QACos Intrinsic

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.

12.5.2.97 QACosD Intrinsic

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.

12.5.2.98 QASin Intrinsic

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.

12.5.2.99 QASinD Intrinsic

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.

12.5.2.100 QATan Intrinsic

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.

12.5.2.101 QATan2 Intrinsic

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.

12.5.2.102 QATan2D Intrinsic

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.

12.5.2.103 QATanD Intrinsic

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.

12.5.2.104 QCos Intrinsic

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.

12.5.2.105 QCosD Intrinsic

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.

12.5.2.106 QCosH Intrinsic

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.

12.5.2.107 QDiM Intrinsic

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.

12.5.2.108 QExp Intrinsic

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.

12.5.2.109 QExt Intrinsic

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.

12.5.2.110 QExtD Intrinsic

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.

12.5.2.111 QFloat Intrinsic

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.

12.5.2.112 QInt Intrinsic

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.

12.5.2.113 QLog Intrinsic

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.

12.5.2.114 QLog10 Intrinsic

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.

12.5.2.115 QMax1 Intrinsic

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.

12.5.2.116 QMin1 Intrinsic

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.

12.5.2.117 QMod Intrinsic

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.

12.5.2.118 QNInt Intrinsic

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.

12.5.2.119 QSin Intrinsic

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.

12.5.2.120 QSinD Intrinsic

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.

12.5.2.121 QSinH Intrinsic

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.

12.5.2.122 QSqRt Intrinsic

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.

12.5.2.123 QTan Intrinsic

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.

12.5.2.124 QTanD Intrinsic

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.

12.5.2.125 QTanH Intrinsic

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.

12.5.2.126 Rename Intrinsic (function)

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 10.11.9.213 Rename Intrinsic (subroutine).

12.5.2.127 Secnds Intrinsic

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).

12.5.2.128 Signal Intrinsic (function)

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 10.11.9.228 Signal Intrinsic (subroutine).

12.5.2.129 SinD Intrinsic

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.

12.5.2.130 SnglQ Intrinsic

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.

12.5.2.131 SymLnk Intrinsic (function)

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 10.11.9.240 SymLnk Intrinsic (subroutine).

12.5.2.132 System Intrinsic (function)

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 10.11.9.241 System Intrinsic (subroutine).

12.5.2.133 TanD Intrinsic

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.

12.5.2.134 Time Intrinsic (VXT)

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 10.11.9.101 FDate Intrinsic (subroutine), for an equivalent routine.

For information on other intrinsics with the same name: See section 10.11.9.245 Time Intrinsic (UNIX).

12.5.2.135 UMask Intrinsic (function)

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 10.11.9.254 UMask Intrinsic (subroutine).

12.5.2.136 Unlink Intrinsic (function)

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 10.11.9.255 Unlink Intrinsic (subroutine).

12.5.2.137 ZExt Intrinsic

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.