Compaq Fortran
User Manual for
OpenVMS Alpha Systems

Index

Master Alphabetic Index
A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Z

A

Abort

    See Ctrl/C; Ctrl/Y

ACCEPT statement

    See also LRM

Access modes

    See Record access mode

ACCESS specifier #1

ACCESS specifier #2

    See also LRM

Accuracy

    and dummy aliases

    hoisting divide operations

    numerical data I/O

        formatted and unformatted

    qualifiers affecting

        argument use #1

        argument use #2

        constants

        floating-point #1

        floating-point #2

        floating-point #3

        floating-point #4

        floating-point #5

        floating-point #6

        floating-point underflow

    source code changes affecting calculations

ACTION specifier

    See also LRM

Actual arguments

    See also Arguments

Address correlation table

    effect of /DEBUG qualifier

Addresses

    64-bit (cDEC$ ATTRIBUTES ADDRESS64 directive)

ADVANCE specifier

    See also LRM

Advancing I/O

AIMAG intrinsic function

    qualifier controlling size returned

    See also LRM

Alignment

    argument passing

        Compaq Fortran and C structures

    array elements

    cDEC$ OPTIONS directive

    checking for unaligned data #1

    checking for unaligned data #2

    common block data

    derived-type data

    detecting unaligned data (compile-time) #1

    detecting unaligned data (compile-time) #2

    detecting unaligned data (run-time)

        condition handler

        debugger

    effect of declaration statements

    locating unaligned data (debugger)

    naturally aligned data (definition)

    of data types #1

    of data types #2

    qualifiers controlling #1

    qualifiers controlling #2

        messages (compile-time) #1

        messages (compile-time) #2

        warnings for unaligned data

    record structures

    SEQUENCE statement

        effect on derived-type data #1

        effect on derived-type data #2

    unaligned data (definition)

    warning messages for unaligned data

/ALIGNMENT=COMMONS qualifier

    effect of /FAST qualifier #1

    effect of /FAST qualifier #2

/ALIGNMENT=NOSEQUENCE qualifier #1

/ALIGNMENT=NOSEQUENCE qualifier #2

/ALIGNMENT qualifier #1

/ALIGNMENT qualifier #2

    [NO]SEQUENCE keyword

Allocating disk space

    SYS$EXTEND (RMS)

Allocating virtual memory

    LIB$GET_VM

    See also LRM

Allocation control block

    XABALL (RMS)

Allocation listing, memory

    linker output #1

    linker output #2

Alpha processor generation

    specifying code generation instruction types #1

    specifying code generation instruction types #2

    specifying for optimization #1

    specifying for optimization #2

Alternate key fields (indexed files)

    definition

    discussion of use

ANA file type

Analysis file

    created by FORTRAN command

/ANALYSIS_DATA qualifier

Annotations

    example

/ANNOTATIONS qualifier

APPEND specifier

    See also LRM

/ARCHITECTURE qualifier #1

/ARCHITECTURE qualifier #2

Argument passing

    64-bit addressing (cDEC$ ATTRIBUTES)

    alignment of data passed

    C and Compaq Fortran #1

    C and Compaq Fortran #2

        alignment of structures

        arrays

        cDEC$ ATTRIBUTES C directive

        changing default mechanisms #1

        changing default mechanisms #2

        changing default mechanisms #3

        common block values

        complex data example

        data types

        examples #1

        examples #2

        examples #3

        examples #4

        integer data example

        pointer data #1

        pointer data #2

        structures

        using C conventions

    character constant actual arguments

    characters

        null terminated

    Compaq Fortran

        array descriptor format

        array temporary creation

        arrays

        built-in functions

        by address (%LOC)

        by descriptor (%DESCR)

        by reference (%REF)

        by value (%VAL)

        changing default mechanisms #1

        changing default mechanisms #2

        changing default mechanisms #3

        characters #1

        characters #2

        default passing mechanism

        explicit interface

        implicit interface #1

        implicit interface #2

        omitted arguments (extra comma)

        pointers

        rules

    Compaq Fortran 77 and Compaq Fortran #1

    Compaq Fortran 77 and Compaq Fortran #2

        alignment qualifiers

        common block values

        data type sizes

        data types to avoid

        derived-type data

        differences

        examples

        function values #1

        function values #2

        I/O compatibility

        mechanisms

        passing target or pointer data

        pointer data

        similarities

        using Compaq Fortran 77 features

    directives (cDEC$ ATTRIBUTES)

    efficient array use

    OpenVMS calling standard

    OpenVMS mechanisms

    RMS arguments

    when temporary array copy is created

Arguments

    actual

        character constant

        differences between Compaq Fortran 77 and Compaq Fortran

    dummy

        aliasing and accuracy #1

        aliasing and accuracy #2

        and implied-DO loop collapsing

    maximum allowed

        in a function reference

        on CALL statement

    memory allocation

    OpenVMS standard for

    qualifier controlling warning messages

    See also Argument passing; LRM

Arithmetic exception handling

    causes of exceptions

    compiler options

        /CHECK

        /FAST

        /FLOAT

        /IEEE_MODE qualifier

        /MATH_LIBRARY

        /SYNCHRONOUS_EXCEPTIONS

    continuation

    controlling reporting of exceptions #1

    controlling reporting of exceptions #2

    controlling reporting of exceptions #3

    error reporting

    exceptional value message reporting

    floating point

        array bounds checking

        certain exponentiation expressions

        control IEEE exceptions

        controlling reporting of exceptions #1

        controlling reporting of exceptions #2

        controlling reporting of exceptions #3

        exceptional values #1

        exceptional values #2

        exceptional values #3

        handling of minus zero

        math library used #1

        math library used #2

        reporting underflow messages

        types used in memory

        underflow #1

        underflow #2

        underflow #3

    IEEE NaN values (quiet and signaling)

    infinity values

    integer overflow #1

    integer overflow #2

    locating exceptions in debugger

    qualifiers needed to obtain traceback information

    See also Condition-handler routines

    setting breakpoints in the debugger

    using a condition handler routine #1

    using a condition handler routine #2

Arithmetic exceptions

    See Arithmetic exception handling; Exception conditions

Arithmetic operators

    for efficient run-time performance

Array references

    /CHECK options at compilation

Arrays

    accessing in debugger

    alignment

    allocatable

    and explicit interface #1

    and explicit interface #2

    and explicit interface #3

    arguments #1

    arguments #2

    arguments #3

        Compaq Fortran 77 and Compaq Fortran similarities

        example #1

        example #2

        example (C and Compaq Fortran)

        See also LRM

    array temporary creation

    assumed-shape #1

    assumed-shape #2

    assumed-shape #3

    assumed-shape #4

    bounds run-time checking

    character

    column-major order #1

    column-major order #2

    compiler checking for out-of-bounds references

    conformable

    declaring

        See LRM

    deferred-shape #1

    deferred-shape #2

    differences between Compaq Fortran and C

    dimension limits

    efficient combinations of input and output arguments

    efficient syntax in I/O list

    efficient use

    element sequence association

    explicit-shape

        example passing #1

        example passing #2

    natural storage order

    optimizations #1

    optimizations #2

    output listing information

    passing as arguments

        example

    row-major order #1

    row-major order #2

    See also Argument passing; LRM

    syntax for run-time efficiency

    using efficiently

    when temporary copy is created for argument passing

    writing for efficiency

Assembly code

    used to represent object code

ASSIGN command (DCL)

ASSOCIATEVARIABLE specifier

    See also LRM

Association

    host

    procedure interface

    use

        procedure interface block #1

        procedure interface block #2

/ASSUME qualifier

    ALTPARAM keyword

    BUFFERED_IO keyword

    BYTERECL keyword

    DUMMY_ALIASES keyword #1

    DUMMY_ALIASES keyword #2

    DUMMY_ALIASES keyword #3

    FP_CONSTANT keyword #1

    FP_CONSTANT keyword #2

    MINUS0 keyword

    NOACCURACY_SENSITIVE keyword #1

    NOACCURACY_SENSITIVE keyword #2

    PROTECT_CONSTANTS keyword

    SOURCE_INCLUDE keyword

Asynchronous reentrancy

    effect on RTL

Asynchronous System Trap (AST) procedures

    example use

/AUTOMATIC qualifier #1

/AUTOMATIC qualifier #2

Automatic storage

    arguments

    of variables on run-time stack

B

BACKSPACE statement #1

BACKSPACE statement #2

Basic linear algebra routines (Compaq Extended Math Library)

Batch job

    compiler errors during

    effect on /LIST qualifier default

Bit manipulation functions

    See LRM

$BLANK program section

    use and attributes

BLANK specifier

    Compaq Fortran 77 differences

    See also LRM

BLAS routines (Compaq Extended Math Library)

Block IF statement

    nesting limit

    See also LRM

BLOCKSIZE specifier #1

BLOCKSIZE specifier #2

    See also LRM

Bottleneck

    reduction of I/O

$BSS$ program section

    use and attributes

BUFFERCOUNT specifier #1

BUFFERCOUNT specifier #2

    See also LRM

Buffers

    for record I/O

Built-in functions

    %DESCR function

    %LOC function

    %REF function

    See also LRM; cDEC$ ATTRIBUTES

    used in passing arguments

    %VAL function

/BY_REF_CALL qualifier

C

C language

    argument passing with Compaq Fortran

        examples #1

        examples #2

        examples #3

    calling between Compaq Fortran and C #1

    calling between Compaq Fortran and C #2

    compiling programs

    example array passing

    example of function call by Compaq Fortran #1

    example of function call by Compaq Fortran #2

    example of function call by Compaq Fortran #3

    handling arrays

    See also Argument passing; Language interfaces

Call stack

    use by CHF

CALL statement

    maximum arguments allowed

    See also LRM

    used to call system services

Calling interface

    See Argument passing; Language interface

CARRIAGECONTROL specifier #1

CARRIAGECONTROL specifier #2

CARRIAGECONTROL specifier #3

    effect of /CCDEFAULT qualifier

    See also LRM

Case sensitive

    external names in C

        controlling with cDEC$ directives #1

        controlling with cDEC$ directives #2

Case-sensitive names

    flagging lowercase (/STANDARD)

    option controlling

Catchall condition handler

/CCDEFAULT qualifier

cDEC$ ALIAS directive

cDEC$ ATTRIBUTES

    ADDRESS64 directive

    ALIAS directive

    C directive

        example

    EXTREN directive

    REFERENCE directive

    VALUE directive

    VARYING directive

cDEC$ ATTRIBUTES directive

cDEC$ directives #1

cDEC$ directives #2

cDEC$ OPTIONS directive

    and alignment

cDEC$ PSECT directive

    changing attributes

Cells

    in relative files

CHAR intrinsic

CHAR intrinsic procedure

    to null-terminate a C string

CHARACTER

    data type

        representation

    See also LRM

Character arguments

    constant actual arguments

    passing between Compaq Fortran and C

Character data

    checking for out-of-bounds references

    constant actual arguments

    using whole character string operations for run-time efficiency

Character set

    See LRM #1

    See LRM #2

Characters

    flagging lowercase (/STANDARD)

/CHECK qualifier

    ALL keyword

    ARG_TEMP_CREATED keyword

    BOUNDS keyword

    FORMAT keyword

    FP_EXCEPTIONS keyword

    NONE keyword

    OUTPUT_CONVERSION keyword

    OVERFLOW keyword

    POWER keyword

    UNDERFLOW keyword

CHF

    See Condition-Handling Facility (CHF); Condition-handler routines

$CHFDEF library module

    in FORSYSDEF #1

    in FORSYSDEF #2

Close operations

    CLOSE statement #1

    CLOSE statement #2

    closing a file using RMS

CLOSE statement #1

CLOSE statement #2

    See also LRM

CMPLX intrinsic function

    qualifier controlling size returned

    See also LRM

Code generation

    for specific Alpha processor generation

Code hoisting

    in divide operations

    in optimization

$CODE$ program section

    use and attributes

COM file type

Command line

    abbreviating list of input files

    abbreviating qualifier names and keywords

    consistent use of qualifiers for multiple compilations

    differences from Compaq Fortran 77 for OpenVMS VAX Systems

    See also Compiler options; FORTRAN command; LINK command; DEBUG command; DEFINE command; DEASSIGN command

    specifying multiple keywords for a qualifier

Command procedures

    returning status values to

    to measure run-time performance

Comment lines

    D in column 1 (/D_LINES)

    See also LRM

Common blocks

    accessing variables in debugger

    alignment of data in

    causes of misalignment

    changing program section attributes

    installed

        creation, installation, and use

        synchronizing access

    order of data in

    program section (PSECT) attributes

    qualifiers controlling alignment

    See also LRM #1

    See also LRM #2

    shared interprocess

        example

    use of VOLATILE statement

COMMON statement

    and data-flow and split lifetime analysis

    causes of misalignment

    data alignment #1

    data alignment #2

    See also LRM; Common block

Common subexpression elimination

Communications, network task-to-task

Compaq Extended Math Library

    See CXML library

Compaq Fortran

    array temporary creation

    condition symbols

        for run-time errors

    for OpenVMS systems

        compatibility

        extensions not supported

    logical names

        defaults and use

        FOR$ACCEPT, FOR$READ, FOR$PRINT, FOR$TYPE

        summary of

    logical unit numbers

    online help #1

    online help #2

    online language help

    online release notes

    sample main and subprogram #1

    sample main and subprogram #2

    See also Compiler; FORTRAN command

    software patch kits

    statements

        coding restrictions and limits summary

    support

    version number

        obtaining from command line

        obtaining from listing file

        obtaining from object file

    Web page

Compaq Fortran 77

    compiler diagnostic detection differences

    for OpenVMS Alpha systems

        argument passing

        calling between Compaq Fortran

        compiler detection differences

        I/O to same unit number

        language features not supported

        passing aligned data

        passing common block values

        passing pointers

        passing same size data

    for OpenVMS VAX systems

        compatibility

        equivalent record types

        floating-point format differences

        FORTRAN command qualifier

        language features not supported

        porting data

        VAX H_float representation

    other platforms

        language compatibility (summary)

    record type portability

    request Fortran 77 compiler (/OLD_F77)

Compaq Fortran 77 OpenVMS Alpha systems

    mixed language example

Compatibility

    DO loop minimum iteration count (/NOF77)

    OPEN statement specifier defaults (/NOF77)

    PARAMETER syntax (/ASSUME)

    request Compaq Fortran 77 compiler (/OLD_F77)

    See also LRM

    translated images

        FORTRAN command

        LINK command #1

        LINK command #2

    unformatted files record length unit, RECL (/ASSUME)

    with Compaq Fortran 77 for OpenVMS Alpha Systems

        command line

        feature summary

        I/O compatibility

        language features #1

        language features #2

        language features #3

        request Fortran 77 compiler (/OLD_F77)

    with Compaq Fortran 77 for OpenVMS VAX Systems

        architectural differences

        command line

        converting data

        feature summary

        interpretation differences

        language features #1

        language features #2

        language features #3

        porting data

        record types

        translated images

        /VMS qualifier

    with Compaq Fortran for Tru64 UNIX systems

        feature summary

        record types

    with Compaq Fortran on other platforms

    with Compaq Visual Fortran

        feature summary

Compile-time operations #1

Compile-time operations #2

Compiler

    assumptions (/ASSUME)

    coding restrictions summary of

    data format assumptions (/CONVERT)

    data format assumptions (/FLOAT)

    data porting assumptions

    default file names

    effect of directives on performance

    effect of optimization level on compilation time and object file size

    functions

    input to linker

    limits

    messages issued by

        compiler-fatal messages

        general description

        limiting

        source program messages

    process memory size

    process open file limit

    request Compaq Fortran 77 compiler (/OLD_F77)

    request threaded run-time execution

    See also FORTRAN command

    using latest version for run-time efficiency

Compiler directives

    cDEC$ ALIAS

    cDEC$ ATTRIBUTES

    cDEC$ OPTIONS directive

    cDEC$ PSECT

    OPTIONS statement #1

    OPTIONS statement #2

    See also LRM

Compiler options

    accuracy

        checking overflow, bounds, underflow (/CHECK)

        dummy variable use (/ASSUME)

        floating-point calculations (/ASSUME)

        floating-point format (/FLOAT)

        handling of single-precision constants (/ASSUME)

        IEEE exception handling (/IEEE_MODE)

        IEEE rounding mode (/ROUNDING_MODE)

        math routines used (/MATH_LIBRARY)

        REAL and COMPLEX declarations (/REAL_SIZE)

        set multiple qualifiers (/FAST)

        size of DOUBLE PRECISION declarations (/DOUBLE_SIZE)

    Alpha processor code generation (/ARCHITECTURE)

    arguments

        case sensitivity of external names (/NAMES)

        character constant actual arguments

        dummy variable use (/ASSUME)

    code generation for Alpha processor (/ARCHITECTURE)

    Compaq Fortran 77 for OpenVMS VAX Systems specific

    compatibility

        Compaq Fortran 77 compiler (/OLD_F77)

        Compaq Fortran 77 for OpenVMS VAX Systems (/VMS)

        data alignment errors

        dummy arguments (/ASSUME)

        floating-point constants (/ASSUME)

        FORTRAN 66 processing (/F77)

        Fortran 90 standard conformance (/STANDARD)

        Fortran 95 standard conformance (/STANDARD)

        integer constants (/ASSUME)

        pad source lines with spaces (/PAD_SOURCE)

        PARAMETER syntax (/ASSUME)

        requesting compiler diagnostics (/WARNINGS)

        translated images (/TIE)

        unformatted files record length unit, RECL (/ASSUME)

    compatibility with Compaq Fortran 77 for OpenVMS VAX Systems

    data

        alignment (/ALIGNMENT)

        automatic storage (/AUTOMATIC)

        DOUBLE PRECISION declaration size (/DOUBLE_SIZE)

        floating-point constants (/ASSUME)

        IEEE exception handling (/IEEE_MODE)

        IEEE floating-point value of -0.0 (/ASSUME)

        IEEE rounding mode (/ROUNDING_MODE)

        INTEGER and LOGICAL declaration size (/INTEGER_SIZE)

        integer constants (/ASSUME)

        memory floating-point data type (/FLOAT)

        REAL and COMPLEX declaration size (/REAL_SIZE)

        recursive procedures (/RECURSIVE)

        shared memory granularity (/GRANULARITY)

        unformatted file data types (/CONVERT)

        unformatted files record length unit, RECL (/ASSUME)

    debugging

        fixed-form source (/D_LINES)

        /OPTIMIZE

        suggested /OPTIMIZE use

        symbol table and traceback (/DEBUG)

    files

        directory search for include or module files (/INCLUDE)

        directory to place module files

        locating and placing include files

        object file (/OBJECT)

        request listing file (/LIST)

        requesting analysis file (/ANALYSIS_DATA)

        requesting diagnostic file (/DIAGNOSTICS)

        specify text library file (/LIBRARY)

        using module (F90$MOD) files

    fixed-form source

        D in column 1 (/D_LINES)

        pad source lines with spaces (/PAD_SOURCE)

        source line length (/EXTEND_SOURCE)

        specify source form (/SOURCE_FORM)

    functional groups of qualifiers

    listing file

        controlling contents of (/SHOW)

        object code listing (/MACHINE_CODE)

        request listing file (/LIST)

    messages

        accurate reporting of exceptions (/SYNCHRONOUS_EXCEPTIONS)

        changing severity of (/SEVERITY)

        limiting (/ERROR_LIMIT qualifier)

        requesting additional (/WARNINGS)

        requesting fewer (/WARNINGS)

        run-time checking (/CHECK)

        standard conformance (/STANDARD)

    not available in Compaq Fortran 77 for OpenVMS VAX Systems

    object file

        name (/OBJECT)

        one or multiple modules in object file (/SEPARATE_COMPILATION)

        prevent creation of (/NOOBJECT)

        symbol table and traceback (/DEBUG)

        translated images (/TIE)

    only check for syntax (/SYNTAX_ONLY)

    optimization (/OPTIMIZE)

    output buffer use (/ASSUME)

    pad source lines with spaces (/PAD_SOURCE)

    performance

        alignment (/ALIGNMENT)

        controlling code generation (/ARCHITECTURE)

        floating-point calculations (/ASSUME)

        floating-point format (/FLOAT)

        IEEE exception handling (/IEEE_MODE)

        INTEGER and LOGICAL defaults (/INTEGER_SIZE)

        math routines used (/MATH_LIBRARY)

        optimization (/OPTIMIZE)

        set multiple qualifiers (/FAST)

        summary

    recursive procedures (/RECURSIVE)

    reentrancy during RTL calls (/REENTRANCY)

    run-time checking

        accurate reporting of exceptions (/SYNCHRONOUS_EXCEPTIONS)

        IEEE exception handling (/IEEE_MODE)

        requesting additional (/CHECK)

    See also FORTRAN command

    version number (/VERSION)

Compiler summary

    output listing section

Compiling C language programs

Completion status values

    returning to command procedure

Complex data types #1

Complex data types #2

Complex data types #3

    declarations and qualifiers

    native representation

    ranges

    See also LRM

    VAX representation

COMPLEX declarations

    option to control size of

Condition-handler routines

    catchall condition handler

    checking for arithmetic exceptions #1

    checking for arithmetic exceptions #2

    checking for data alignment traps

    coding requirements

    converting signal to return status

        LIB$SIG_TO_RET

    definition of

    establishing handlers

        LIB$ESTABLISH

    examples of use

    matching condition values

        LIB$MATCH_COND

    removing handlers

        LIB$REVERT

    return values

        SS$_CONTINUE

        SS$_RESIGNAL

    returning from a handler

    See also Condition-Handling Facility (CHF); Error handling

    signaling exception conditions

        LIB$SIGNAL or LIB$STOP

    terminating handling for signals

        LIB$SIG_TO_STOP

    traceback condition handler

    unwinding the call stack

        SYS$UNWIND

    user written

        use of variables

    values and symbols passed

Condition-Handling Facility (CHF)

    contrasted with U*X Signal Facility

    default condition handlers

    overview

    See also Condition-handler routines

    use of call stack

Condition signals

    changing to return status

        LIB$SIG_TO_RET

Condition symbols, Fortran

    summary of

Constant operation

    See Compile-time operations

Constants

    alternate PARAMETER syntax (/ASSUME)

    character actual arguments

    floating-point

        double precision

    maximum size

    ranges

    See also LRM

CONTAINS statement

    See also LRM

Continuation lines

    maximum allowed

    See also LRM

CONTINUE command (DCL)

/CONVERT qualifier #1

/CONVERT qualifier #2

/CONVERT qualifier #3

    BIG_ENDIAN keyword

    CRAY keyword

    FDX keyword

    FGX keyword

    IBM keyword

    LITTLE_ENDIAN keyword

    NATIVE keyword

    VAXD keyword

    VAXG keyword

CONVERT specifier #1

CONVERT specifier #2

    See also LRM

Cross-reference information

    linking

        /CROSS_REFERENCE qualifier

Ctrl/C

    handling

        example routine #1

        example routine #2

    handling routine

    interrupting interactive program execution

Ctrl/Y

    interrupting interactive program execution

CVT$CONVERT_FLOAT

    example use

CXML library

    example program

    for efficient run-time performance

    groups of routines

    linking

    types of libraries provided

D

D, in column 1

    qualifier controlling debugging indicator

Data

    alignment

        checking for unaligned data

        definition

        detecting unaligned data #1

        detecting unaligned data #2

        effect of FORTRAN command qualifiers

        effect of statements

        placing declaration statements to avoid unaligned data

        unaligned arguments

    big endian

        definition

        numeric formats

        unformatted file formats

    comparison of formatted and unformatted

    COMPLEX

        setting default lengths

    converting unformatted files #1

    converting unformatted files #2

    DOUBLE PRECISION

        setting default lengths

    equivalent types for C and Compaq Fortran

    exchanging

        using mailboxes (SYS$CREMBX)

        using network task-to-task communications

    floating-point formats used in memory

    formats for unformatted files #1

    formats for unformatted files #2

    formatted I/O statements

        Compaq Fortran 77 differences

    granularity of shared access

    INTEGER

        setting default lengths

    items in common blocks

        controlling alignment #1

        controlling alignment #2

    items in derived-type data

        controlling alignment #1

        controlling alignment #2

    items in record structures

        controlling alignment #1

        controlling alignment #2

    list-directed I/O

        Compaq Fortran 77 differences

        statements

    little endian

        definition

    LOGICAL

        setting default lengths

    namelist I/O statements

        Compaq Fortran 77 differences

    nonnative numeric formats

    nonnative VAX H_float formats

    porting between Compaq Fortran and Compaq Fortran 77 for OpenVMS VAX Systems

    REAL

        setting default lengths

    representation

    See also Data types; Files; I/O; LRM

    shared memory access #1

    shared memory access #2

    sharing

        in files

        in installed common areas

        in shareable image libraries

        using global pagefile section

    size and handling

        qualifiers for DOUBLE PRECISION declarations #1

        qualifiers for DOUBLE PRECISION declarations #2

        qualifiers for INTEGER and LOGICAL declarations

        qualifiers for REAL and COMPLEX declarations

    storage (automatic or static)

    stored by Compaq Fortran

    translation of formatted

    unformatted I/O statements

    use of VOLATILE statement

    VAX floating-point formats

    zero-extended and sign-extended values

Data file

    advancing and nonadvancing I/O

    big endian

        porting notes

        unformatted numeric formats

    characteristics

    CLOSE statement

    comparison of formatted and unformatted

    converting unformatted files

        limitations

    efficient run-time performance

    handling I/O errors

    I/O unit

    INQUIRE statement

    internal

    nonnative

        VAX H_float format

    obtaining file characteristics (INQUIRE statement)

    OPEN statement

    opening using

        OPEN statement

        preconnected files

        SYS$OPEN #1

        SYS$OPEN #2

        USEROPEN routine

    organization

    RECL units for unformatted files

    record

        I/O statements

        position

        transfer

        types

    scratch

    unformatted nonnative numeric formats

    VAX floating-point formats

Data-flow and split lifetime analysis #1

Data-flow and split lifetime analysis #2

$DATA$ program section

    use and attributes

DATA statement

    and value propagation #1

    and value propagation #2

    See also LRM

Data structures

    See Derived-type data; Records; RMS data structures; Structures

Data types

    alignment of #1

    alignment of #2

    Alpha IEEE X_float representation

        REAL*16

    big endian

        definition

        unformatted file formats #1

        unformatted file formats #2

    character representation

    common block handling between Compaq Fortran and C

    comparison of VAX and Alpha floating-point formats

    COMPLEX

        representation #1

        representation #2

        setting default lengths

    derived-type data alignment

    differences between Compaq Fortran and C

    differences between Compaq Fortran and Compaq Fortran 77 for OpenVMS VAX Systems

    DOUBLE PRECISION declarations

        qualifiers controlling size #1

        qualifiers controlling size #2

    equivalent in C and Compaq Fortran

    exceptional floating-point numbers

    for efficient run-time performance

    formats for unformatted files #1

    formats for unformatted files #2

    Hollerith representation

    IEEE S_float representation

        COMPLEX*8

        REAL*4

    IEEE T_float representation

        COMPLEX*16

        REAL*8

    IEEE X_float representation

        COMPLEX*32

    INTEGER

        representation

        setting default lengths

    little endian

        definition

        unformatted file formats #1

        unformatted file formats #2

    LOGICAL

        representation

        setting default lengths

    methods of using nonnative formats

    mixed operations and run-time performance

    native data representation

    native IEEE floating-point representation

    nonnative

        formats for unformatted file conversion

        VAX H_float representation

    OpenVMS calling standard

    ranges

        denormalized native floating-point data #1

        denormalized native floating-point data #2

        native numeric types

        VAX floating-point types

    REAL

        representation

        setting default lengths

    See also Floating-point data types; Integer data type; Logical data type; LRM

    sizes for efficient run-time performance

    VAX D_float representation

        COMPLEX*16

        REAL*8

    VAX F_float representation

        COMPLEX*8

        REAL*4

    VAX G_float representation

        COMPLEX*16

        REAL*8

    VAX H_float representation

        equivalent on Alpha systems

Date and time control block

    XABDAT (RMS)

DBG$PROCESS

Dead store elimination

Deallocating virtual memory

    LIB$FREE_VM

DEASSIGN command (DCL)

DEBUG command

/DEBUG qualifier #1

/DEBUG qualifier #2

    ALL keyword

    NONE keyword

    on FORTRAN command #1

    on FORTRAN command #2

    on LINK command #1

    on LINK command #2

    on LINK command #3

    on LINK command #4

    on RUN command

    SYMBOLS keyword

    TRACEBACK keyword

Debugger

    accessing

        array variables

        common block variables

        derived-type variables

        record structure variables

        variables in modules

    breakpoints #1

    breakpoints #2

    character-cell interface

        line mode

        screen mode

    command summary

    commands

        call

        changing values

        controlling execution

        deposit

        displaying source lines

        displaying values

        examine

        exit

        for breakpoints

        for kept debugger

        for tracepoints

        for watchpoints

        go

        help

        spawn

        step

        stop

        type

        used often

    Compaq Fortran support

    compiler qualifier

    debugging configuration

    detecting an exception

    detecting unaligned data

    displaying

        online help

        values

    examining variables

    executing DCL commands

    exiting

    getting started

    invoking #1

    invoking #2

    /KEEP qualifier

    kept debugger

    locating an exception #1

    locating an exception #2

    locating unaligned data

    logical names

    Motif windowing interface

    restarting

    sample FORTRAN command #1

    sample FORTRAN command #2

    sample session

    windowing interface

Debugging statement indicator

    in fixed-form source code

Declarations

    misalignment and COMMON, STRUCTURE, TYPE statements

    See also LRM

DECnet

    using to share and exchange data

DECwindows Motif

    windowing interface to the OpenVMS Debugger

Default

    file names

    logical I/O unit names

DEFAULTFILE specifier #1

DEFAULTFILE specifier #2

    See also LRM

DEFINE command (DCL)

DEFINE FILE statement

    See also LRM

DELETE statement

    See also LRM

DELIM specifier

    See also LRM

Denormalized numbers (IEEE)

    double-precision range

    exponent value of

    /IEEE_MODE qualifier

    single-precision range

    S_float range

    T_float range

    X_float range (IEEE Alpha)

Derived-type data

    accessing variables in debugger

    causes of misalignment

    controlling alignment of multiple data items #1

    controlling alignment of multiple data items #2

    data alignment

    order of members #1

    order of members #2

    order of members #3

    qualifiers controlling alignment #1

    qualifiers controlling alignment #2

    qualifiers controlling alignment #3

    See also LRM

    SEQUENCE statement #1

    SEQUENCE statement #2

    SEQUENCE statement #3

    SEQUENCE statement #4

%DESCR function

    See also Argument passing

Descriptor

    array format #1

    array format #2

    character

    Compaq Fortran built-in functions

    memory allocation

    types of arguments generating

    used for different argument types

DIA file type

Diagnostic file

    created by FORTRAN command

Diagnostic Messages

    See Messages; Warning messages

/DIAGNOSTICS qualifier

Direct access

Direct access file

    RECL values

Direct access mode

    relative files

    requirements for sequential files

    See also Relative file

Directives

    cDEC$

    cDEC$ ALIAS

    cDEC$ ATTRIBUTES #1

    cDEC$ ATTRIBUTES #2

        ADDRESS64

        ALIAS

        C

        REFERENCE

        STRUCT

        VALUE

    related to performance

    See LRM; OPTIONS statement; cDEC$

Directory

    application of defaults

    default for OPEN statement

    effect of DEFAULTFILE specifier

    I/O statements default use

    in I/O statements

    OPEN statement specifiers #1

    OPEN statement specifiers #2

    searched for module and include files #1

    searched for module and include files #2

    searched for text library files

Directory entries

    system services affecting

        list of

Disk space allocation

    SYS$EXTEND (RMS)

DISPOSE specifier #1

DISPOSE specifier #2

    See also LRM

DO loops

    blocking optimization #1

    blocking optimization #2

    distribution optimization #1

    distribution optimization #2

    fusion optimization #1

    fusion optimization #2

    interchange optimization #1

    interchange optimization #2

    limiting loop unrolling

    outer loop unrolling optimization #1

    outer loop unrolling optimization #2

    qualifier controlling minimum iteration count (/NOF77)

    scalar replacement optimization #1

    scalar replacement optimization #2

    See also LRM

    software pipelining optimization #1

    software pipelining optimization #2

    software pipelining optimization #3

    software pipelining optimization #4

    transformation optimizations #1

    transformation optimizations #2

    transformation optimizations #3

    use for efficient run-time performance

DO statement

    nesting limit

    See also LRM

Documentation

    sending comments to Compaq

Dot product operation

    and /ASSUME=NOACCURACY_SENSITIVE qualifier

DOUBLE PRECISION declarations

    option to control size of

    qualifiers to control size of

/DOUBLE_SIZE qualifier

Dummy arguments

    and accuracy

    and implied-DO loop collapsing

    qualifier for aliasing #1

    qualifier for aliasing #2

    See also LRM

DXML

    See CXML library

D_float data

    See Floating-point data types

/D_LINES qualifier

E

Edit descriptors

    See LRM #1

    See LRM #2

END branch specifier #1

END branch specifier #2

END branch specifier #3

END branch specifier #4

    See also LRM

END statement

    effect on program execution

    when not to use

ENDFILE statement #1

ENDFILE statement #2

    See also LRM

Endian

    big and little types

Entry point

    main

    output listing information

ENTRY statement

    See LRM

EOR branch specifier #1

EOR branch specifier #2

    See also LRM

EQUIVALENCE statement

    and data alignment

    and implied-DO loop collapsing

    causing data spanning natural boundaries

    causing unaligned data #1

    causing unaligned data #2

    preventing implied-DO loop collapsing

    preventing optimizations

    See also LRM; Program section

Equivalenced structures

    in data-flow and split lifetime analysis

ERR branch specifier #1

ERR branch specifier #2

ERR branch specifier #3

    example

    See also LRM

Error handling

    arithmetic exception handling #1

    arithmetic exception handling #2

    condition handlers #1

    condition handlers #2

    list of run-time errors (numeric order)

    obtaining secondary status codes

    processing performed by Compaq Fortran RTL

    run-time error explanations

    See also END; EOR; ERR; IOSTAT; Run-time messages

    user controls in I/O statements #1

    user controls in I/O statements #2

    user controls in I/O statements #3

    user controls in I/O statements #4

        END, EOR, ERR, and IOSTAT specifiers #1

        END, EOR, ERR, and IOSTAT specifiers #2

        See also LRM

Error-related command qualifiers

    FORTRAN, LINK, RUN (DCL)

        summary

Errors

    compiler

        effect on linker

        /ERROR_LIMIT qualifier

        fatal

        format

        See also Messages

        severity

        source messages

    linker #1

    linker #2

    operating system #1

    operating system #2

    run-time system #1

    run-time system #2

        format

        handling

        requesting precise reporting

        requesting traceback information (FORTRAN)

        requesting traceback information (LINK)

        severity

        symbols

        using debugger to locate

    See also Error handling; Messages; Condition-handler routines

/ERROR_LIMIT qualifier

ERRSNS (compatibility)

    example use #1

    example use #2

    obtaining secondary status codes

Escape sequences

Event handling

    See Condition-handler routines

Exception condition

    common when using indexed files

    definition

    See also Condition-handler routines; Error handling

Exception handling

    See Arithmetic exception handling

Exceptional IEEE floating-point values #1

Exceptional IEEE floating-point values #2

EXE file type

/EXECUTABLE option (LINK) #1

/EXECUTABLE option (LINK) #2

Executable programs

    creating #1

    creating #2

    effect of optimization level on size

    naming

    running

    See also Program

Execution

    interrupting execution of program

        example of handling Ctrl/C #1

        example of handling Ctrl/C #2

EXIT command (DCL)

EXIT system subroutine

Expanded String Area (ESA)

    RMS control structure #1

    RMS control structure #2

Explicit interface

    and array descriptors

    calling non-Fortran subprograms

    passing arrays #1

    passing arrays #2

    passing arrays #3

    passing pointers #1

    passing pointers #2

    passing pointers #3

    procedure interface block

    See also LRM

    types of subprograms

    when calling C subprograms

Expressions

    parentheses in

        maximum allowed

    See also LRM

Extended Attributes Block (XAB)

    general description of use

    initialized after open

    kinds of XABs

        listing of

EXTENDSIZE specifier

/EXTEND_SOURCE qualifier

Extensions

    compatibility with Compaq Fortran 77

    See also LRM

External names

    case-sensitivity

    cDEC$ ALIAS directive #1

    cDEC$ ALIAS directive #2

    controlling with cDEC$ directives #1

    controlling with cDEC$ directives #2

    controlling with cDEC$ directives #3

    in C

    passed between C and Compaq Fortran #1

    passed between C and Compaq Fortran #2

    passed between C and Compaq Fortran #3

    specifying alias names

External procedures

    name passing rule

    references and optimization

EXTERNAL statement

    for C language functions

    qualifier controlling compatibility (/NOF77)

    See also LRM

    when to use for FOR$RAB function

F

F file type

/F77 qualifier

F90 command

    See FORTRAN command

F90 file type

FAB

    See File Access Block (FAB)

$FABDEF library module

    in FORSYSDEF

/FAST qualifier

    effect on /ALIGNMENT=COMMONS=keyword #1

    effect on /ALIGNMENT=COMMONS=keyword #2

Feedback on documentation

    sending comments to Compaq

Field descriptors

    See LRM

Fields

    in common blocks

        causes of misalignment

        controlling alignment #1

        controlling alignment #2

    in derived-type data and record structures

        causes of misalignment

        controlling alignment #1

        controlling alignment #2

        controlling alignment #3

File Access Block (FAB)

    fields for use by USEROPEN

    general description

    symbol naming conventions

File access, remote

File format

    See also Record type; File organization; Formatted data; Unformatted files

File handling #1

File handling #2

    examples of

File header characteristics

    control block for

        XABFHC (RMS)

File name

    application of defaults

    compiler defaults

    I/O statements default use

    in I/O statements

    OPEN statement specifiers #1

    OPEN statement specifiers #2

    See also File specifications

    using logical names to specify

File organization

    available record types

    available storage media

    default

    I/O statement limitations

    I/O statements for

    obtaining

        INQUIRE statement

    overview

    See also Sequential files; Relative files

    stored in file header

File sharing

    accessing remote files

    OPEN statement, SHARED specifier

    RMS file-sharing capability

        example

    shareable image libraries

File specifications

    defining logical names for

    general DCL rules (FORTRAN command)

    OPEN statement specifiers

    use in INQUIRE statement

    use in OPEN statements #1

    use in OPEN statements #2

    use in OPEN statements #3

FILE specifier #1

FILE specifier #2

    example

    See also LRM

File type

    EXE

    executable program

    F

    F90

    F90$MOD

    FOR

    for listing files

    for module files

    for object files

    LIS

    OBJ #1

    OBJ #2

    OLB

    OPT

    recognized by compiler

    STB

    TLB

Files

    assigning to logical units

        default names #1

        default names #2

        preconnected #1

        preconnected #2

        summary of methods

        using logical name #1

        using logical name #2

        using logical name #3

        using OPEN statement #1

        using OPEN statement #2

    closing

        using RMS

    compiler source checking only (no object file) (FORTRAN)

    compiler source listing (FORTRAN)

    compiling multiple input files (FORTRAN)

    controlling include file searching

    created by FORTRAN command

    created by LINK command #1

    created by LINK command #2

    external, definition

    input to FORTRAN command

    input to LINK command

    inquiry

    internal

    naming object file (FORTRAN)

    opening #1

    opening #2

        using RMS

    organization and characteristics

    preconnected

        Compaq Fortran 77 differences

    relative organization

    RMS journaling

    RMS services

        list of

    scratch

    sequential organization

    specifying file specification

        example program

%FILL

    example use

FIND statement

    See also LRM

Fixed-length records

    data transferred by I/O statements

    use for optimal performance

FLOAT function

    example use

FLOAT intrinsic function

    qualifier controlling size returned

    See also LRM

/FLOAT qualifier

    D_FLOAT keyword

    G_FLOAT keyword

    IEEE_FLOAT keyword

Floating-point data types

    accuracy-sensitive optimization

    Alpha IEEE X_float

    arithmetic exception handling #1

    arithmetic exception handling #2

    array out-of-bounds checking

    comparison of VAX and Alpha types

    constants

        request double precision

    controlling size of

        COMPLEX declarations

        DOUBLE PRECISION declarations

        REAL declarations

    controlling type in unformatted files

    conversion

        limitations

    converting H_float data

    CRAY big endian formats

    CVT$CONVERT_FLOAT RTL routine

    declarations and qualifiers

    declaring

        See also LRM

    denormal values

    differences between Compaq Fortran 77 for OpenVMS VAX Systems and Compaq Fortran

    digits of precision

    D_float

        differences between VAX and Alpha systems

    endian (big and little)

    endian order of native formats

    exceptional values #1

    exceptional values #2

    formats used in memory

    handling of certain exponentiation expressions

    handling of minus zero (IEEE)

    handling of single-precision constants

    IBM big endian formats

    IEEE

        Alpha X_float #1

        Alpha X_float #2

        big endian formats (conversion)

        controlling exceptions (/IEEE_MODE)

        denormalized values

        native little endian formats

        reporting exceptional values

        rounding modes

        selecting memory format (/FLOAT)

        S_float #1

        S_float #2

        T_float #1

        T_float #2

    in memory and on disk

    infinity

    math library used #1

    math library used #2

    methods of specifying nonnative formats

    minus zero use (IEEE)

    NaN values

        detecting

    nonnative formats

    normal and denormalized values of native formats

    precision

    qualifiers controlling size of DOUBLE PRECISION declarations

    qualifiers related to accuracy #1

    qualifiers related to accuracy #2

    qualifiers related to accuracy #3

    qualifiers related to accuracy #4

    qualifiers related to accuracy #5

    qualifiers related to accuracy #6

    qualifiers related to accuracy #7

    qualifiers related to accuracy #8

    qualifiers related to exceptions

    ranges #1

    ranges #2

    ranges #3

    reporting exceptional values

    reporting exceptions more precisely

    reporting underflow messages #1

    reporting underflow messages #2

    representation of native IEEE and VAX formats

    representation of VAX H_float format

    representation of zero

    rounding modes (IEEE)

    selecting memory format

    selecting optimal

    setting default length (/DOUBLE_SIZE)

    setting default length (/REAL_SIZE)

    shared memory granularity

    underflow run-time checking

    values for constants

    VAX D_float format #1

    VAX D_float format #2

    VAX D_float format #3

    VAX D_float format #4

    VAX F_float format #1

    VAX F_float format #2

    VAX F_float format #3

    VAX F_float format #4

    VAX little endian formats

    zero values

Flushing data

    output record buffering

FMT specifier

    See also LRM

FOR$

    prefix for condition symbols

        for run-time errors

FOR$CONVERT.ext logical name

    use with nonnative numeric data

FOR$CONVERTnnn logical name

    use with nonnative numeric data

FOR$CONVERT_ext logical name

FOR file type

FOR$IOS

    prefix for condition symbols

        for run-time errors #1

        for run-time errors #2

FOR$RAB function #1

FOR$RAB function #2

    Compaq Fortran 77 for OpenVMS VAX Systems compatibility

    when to declare EXTERNAL

FORALL statement

    array optimizations

    See also LRM

$FORDEF library module

    in FORSYSDEF #1

    in FORSYSDEF #2

$FORIOSDEF library module

    in FORSYSDEF #1

    in FORSYSDEF #2

FORM specifier #1

FORM specifier #2

FORM specifier #3

    See also LRM

Format descriptors

    See LRM

Format groups

    nesting limits

FORMAT statement

    and implied-DO loop collapsing

    See also LRM

Formatted data

    and DO loop collapsing

    and variable format expressions

    Compaq Fortran 77 differences

    effect on run-time performance

    I/O statements for

Formatted I/O statements

    Compaq Fortran 77 differences

    controlling format mismatch handling

    controlling format truncation handling

    See also LRM

FORnnn logical name #1

FORnnn logical name #2

FORSYSDEF

    $CHFDEF library module #1

    $CHFDEF library module #2

    condition symbol values

    example of including a module

    $FABDEF library module

    $FORDEF library module #1

    $FORDEF library module #2

    $FORIOSDEF library module #1

    $FORIOSDEF library module #2

    $LIBDEF library module

    library search order #1

    library search order #2

    list of library modules

    $MTHDEF library module

    $NAMDEF library module

    overview of library module contents

    $RABDEF library module

    $SSDEF library module

    symbol naming conventions

        PARAMETER declarations

    use with RMS services #1

    use with RMS services #2

FORT$LIBRARY

Fortran

    Compaq Fortran implementation of

        PSECT use and attributes

FORTRAN-66

    See FORTRAN IV

Fortran 90

    Standard

        and RECL units for unformatted files

        checking (/STANDARD)

Fortran 90/95

    condition symbols

        See FORSYSDEF

    logical names

        See Logical names

    reusing source file code

    See also FORTRAN command; Compatibility; LRM

    source file contents

    source form

        file type

    Standard

        /ASSUME=DUMMY_ALIASES qualifier #1

        /ASSUME=DUMMY_ALIASES qualifier #2

        See also LRM

    statements

        See LRM; appropriate statement name

Fortran 95

    Standard

        and RECL units for unformatted files

        checking (/STANDARD)

FORTRAN command

    abbreviating qualifier names and keywords

    alignment qualifiers #1

    alignment qualifiers #2

    and other software components

    C language main program

        example

    comma or plus signs between file names

    command qualifiers for efficient run-time performance

    consistent use of qualifiers for multiple compilations

    controlling arithmetic exception handling

    controlling arithmetic exception reporting #1

    controlling arithmetic exception reporting #2

    creating module files

    CXML library for efficient run-time performance

    debugging qualifiers

    directories searched for module and include files #1

    directories searched for module and include files #2

    directories searched for text library files

    effect of compiler directives on qualifiers #1

    effect of compiler directives on qualifiers #2

    effect of file type on source form

    effect of OPTIONS statement on qualifiers

    examples

        application with modules

        compiling multiple files

        for debugging

        module subprogram

        multiple source files #1

        multiple source files #2

        naming object files

        preventing object file creation

        request listing file

        requesting additional checking

        requesting additional optimizations

        requesting Fortran Standard conformance checking

        single file

        source checking only

        using module files #1

        using module files #2

    file type search order

    for efficient run-time performance

    for translated shared images

    format of

    functional groups of qualifiers

    multiple source files

        effect on optimizations

    one or multiple object files per command line #1

    one or multiple object files per command line #2

    See also Compiler options

    specifying

        directory for module files

        files

        include files

        input files

        library files #1

        library files #2

        library files #3

        library files #4

        listing

        listing of include file #1

        listing of include file #2

        listing of include file #3

        multiple keywords for a qualifier

        object files

        output files

        source form

    summary of qualifiers

    using

        include files

        module files #1

        module files #2

        multiple FORTRAN commands

FORTRAN IV

    /F77 qualifier (FORTRAN)

/FULL qualifier (LINK) #1

/FULL qualifier (LINK) #2

FUNCTION statement

    See also LRM

Functions

    C language

        invoking

    declaration statements

    %DESCR, %LOC, %REF, and %VAL

    example

        C language #1

        C language #2

        C language #3

        declaration

        interface block in module

        with module

        with system service

    explicit interface

    output listing information

    return values #1

    return values #2

        changing default passing mechanisms

        passing rules #1

        passing rules #2

        passing with Compaq Fortran

        with C

        with Compaq Fortran 77

    See also LRM; Intrinsic procedures

    setting return values

    using function reference to call system services

F_float data

    See Floating-point data types

G

General directives

    See LRM

General-purpose register

    See Register usage

Global pagefile section

    example use

GOTO statement

    computed or assigned

        maximum labels allowed

    See also LRM

Granularity

    and unaligned data

    importance of VOLATILE declarations

    qualifier controlling warning messages

    shared memory access

/GRANULARITY qualifier

    BYTE keyword

    LONGWORD keyword

    QUADWORD keyword

G_float data

    See Floating-point data types

/G_FLOATING qualifier (obsolete)

H

HELP command

    for FORTRAN command

Help (DEBUG)

    HELP command

Help libraries

    displaying linker message explanations

    displaying run-time message explanations

    obtaining text from

        example of

Help (online)

    Compaq Fortran language

    Compaq Fortran release notes

    Compaq Fortran run-time messages #1

    Compaq Fortran run-time messages #2

    FORTRAN command qualifiers #1

    FORTRAN command qualifiers #2

    operating system messages

Hollerith constants

    maximum size

    representation

    See also LRM

I

I/O

    advancing and nonadvancing

    block mode I/O

        example of using RMS

    choosing optimal record type

    closing files

    Compaq Fortran 77 and Compaq Fortran compatibility

    converting unformatted files

    data formats for unformatted files

    device and buffer use for efficient run-time performance

    eliminating bottlenecks

    file operations

    files and file characteristics

    flushing data

    guidelines for efficient run-time performance

    logical units

    obtaining file information

    output record buffering

    performance

    preconnected files

        Compaq Fortran 77 differences

    reading data using RMS

    record

        access

        buffer use #1

        buffer use #2

        deleting records from a file (DELETE)

        for internal files

        general description

        indexed file record pointers (current and next)

        operations

        record operations on indexed files

        specifiers

        specifying initial position

        transfer

    record-processing RMS services

        list of

    record types

        comparison with Compaq Fortran 77

        portability considerations

    See also Files; Record I/O; I/O statements

    specifying files

    specifying record length for efficiency

    summary of statements

    synchronous

        accessing devices using SYS$QIOW

    writing data using RMS

I/O statements

    advancing and nonadvancing I/O #1

    advancing and nonadvancing I/O #2

    auxiliary

    available for sequential and direct access

    CLOSE statement

    Compaq Fortran extensions

    default devices #1

    default devices #2

    file connection

    file operations

    for indexed files

    for relative files

    for sequential files

    forms of

    implicit logical I/O unit

    INQUIRE statement

    list of

    OPEN statement

        CONVERT specifier

        See also OPEN statement

    OPEN statement interdependencies

        file specification

    preconnected units #1

    preconnected units #2

    record

        access modes

        input

        operations

        output

        position

        transfer

    See also LRM

    with formatted, unformatted, list-directed, and namelist records

/I4 qualifier (obsolete)

IEEE

    controlling exceptions (/IEEE_MODE)

    exception handling

    exceptional floating-point numbers #1

    exceptional floating-point numbers #2

    floating-point data

        exceptional values

        native #1

        native #2

        nonnative big endian #1

        nonnative big endian #2

        representation of zero

    nonnative big endian data #1

    nonnative big endian data #2

    reporting exceptional values

    rounding modes

        floating-point calculations

    See also Floating-point data types

    selecting memory floating-point format (/FLOAT)

    S_float data #1

    S_float data #2

        ranges

    T_float data #1

    T_float data #2

        ranges

IEEE, Alpha

    X_float data #1

    X_float data #2

        ranges

/IEEE_MODE qualifier

    DENORM_RESULTS keyword

    FAST keyword

    UNDERFLOW_TO_ZERO keyword

IF statement

    See LRM

Image files

    creating

Image termination

Implicit interface

    types of subprograms

IMPLICIT NONE statement

    and /WARNINGS=DECLARATIONS qualifier

    See also LRM

Implied-DO loop

    and I/O performance

    collapsing #1

    collapsing #2

INCLUDE files

    directory search order

    including in output listing

        /SHOW qualifier

    locating

    locating in source libraries

    specifying directory

/INCLUDE qualifier

/INCLUDE qualifier (LINK) #1

/INCLUDE qualifier (LINK) #2

INCLUDE statement

    and modules

    file nesting limit

    forms for include files

    forms for text library modules

    library modules in text library

    See also LRM

    specifying directories to search

    text file library search

    using on OpenVMS systems

Indexed sequential files

    creating

    deleting records

    exception conditions

    keyed access

    reading operations

    record access

    record access modes for #1

    record access modes for #2

    record pointers

        next and last

    record types for

    RMS pointers

    See also Keyed access mode

    sequential access

    specifying

    specifying RECL when creating

    updating records

    writing operations

Indexed sequential (keyed) access

Infinity values

    representation in Alpha floating-point data

Initialization

    debugger

INITIALSIZE specifier

Inline expansion

    of statement functions and intrinsics

    subprograms #1

    subprograms #2

    subprograms #3

    subprograms #4

INQUIRE statement #1

INQUIRE statement #2

INQUIRE statement #3

    by file name

    by output item list

    by unit number

    Compaq Fortran 77 differences

    default values returned

    OPENED specifier

    RECL specifier

        qualifier to specify units

    See also LRM

    to an opened file

INSTALL command (VMS)

    use to install shareable images #1

    use to install shareable images #2

Installed common areas

    creation, installation, and use

    synchronizing access

Integer data type

    array out-of-bounds checking

    declarations and qualifiers

    declaring

        See also LRM

    endian order of native formats

    methods of specifying the format

    nonnative formats

    overflow run-time checking

    ranges #1

    ranges #2

    representation

    setting default length

/INTEGER_SIZE qualifier

Interactive program execution

    continuing

    interrupting

Interface block

    components of

    declaration statements

    example

    for explicit procedure interface

    See also LRM

INTERFACE statement #1

INTERFACE statement #2

INTERFACE statement #3

    See also LRM

Internal file

    I/O

    I/O forms and statements

    See also LRM

Internal subprograms

Interoperability with translated images

    FORTRAN command #1

    FORTRAN command #2

    LINK command #1

    LINK command #2

    LINK command #3

    summary

Interprocess communication

    mechanisms supporting

Interrupt from terminal user

    See Ctrl/C; Ctrl/Y

Intrinsic procedures

    argument passing

        differences between Compaq Fortran 77 and Compaq Fortran

    CHAR

        to null-terminate a C string

    FLOAT

    FOR$RAB #1

    FOR$RAB #2

    for timing program execution

    inline expansion of

    ISNAN #1

    ISNAN #2

    LIB$ESTABLISH

    LIB$REVERT

    qualifier controlling size returned #1

    qualifier controlling size returned #2

    qualifiers controlling DOUBLE PRECISION size returned

    requesting faster, less accurate versions

    RESHAPE

    See also LRM

    SIZEOF

    SQRT

    SUM

    UBOUND

    using array

    using existing Compaq Fortran

    ZEXT

IOSTAT specifier #1

IOSTAT specifier #2

IOSTAT specifier #3

IOSTAT specifier #4

    example

    See also LRM #1

    See also LRM #2

ISHFT intrinsic

    See also LRM

ISNAN intrinsic

    See also LRM

Item List control block

    XABITM (RMS)

J

Journaling control block

    XABJNL (RMS)

Journaling (RMS)

K

KAP preprocessor

    improving run-time performance

Key definition control block

    XABKEY (RMS)

Key fields

    primary and alternate

        definition

        discussion of use #1

        discussion of use #2

        discussion of use #3

        discussion of use #4

KEY specifier #1

KEY specifier #2

Keyed access mode

    exception handling

    general discussion

    indexed files

    See also Indexed sequential files

KEYEQ specifier

KEYGE specifier

KEYGT specifier

KEYID specifier

KEYLE specifier

KEYLT specifier

KEYNXT specifier

KEYNXTNE specifier

Keys, primary and alternate

    See Key fields

Keyword options (command line)

    abbreviating

    specifying multiple

Kind type parameter

    COMPLEX declarations

    INTEGER declarations

    LOGICAL declarations

    REAL declarations

    See also LRM

L

Labels

    in computed or assigned GOTO list

        maximum allowed

    See also LRM

Language compatibility

    See Compatibility; Language extensions

Language dialects

    Compaq Fortran compatibility information

Language extensions

    compatibility with Compaq Fortran 77

    compatibility with Compaq Fortran 77 on other platforms

    See also LRM

Language features

    Compaq Fortran 77 on other platforms (summary)

Language interface

    C and Compaq Fortran

        arrays

        C language main program

        calling subroutines

        changing default argument passing mechanisms #1

        changing default argument passing mechanisms #2

        changing default mechanisms

        complex arguments

        handling common blocks

        integer arguments

        invoking a C function from Compaq Fortran

        invoking a Compaq Fortran subprogram from C

        passing arguments between

        passing arguments between #1

        passing arguments between #2

        passing arguments between #3

        using C conventions

        using FORTRAN command

    character constant actual arguments

    Compaq Fortran

        argument passing rules

        array descriptor format

        changing default argument passing mechanisms #1

        changing default argument passing mechanisms #2

        default argument passing mechanism

        explicit interface #1

        explicit interface #2

        passing arguments #1

        passing arguments #2

        passing arguments #3

        passing arrays

        passing character arguments

        passing pointers

        See also LRM

    Compaq Fortran 77 and Compaq Fortran

        alignment qualifiers

        common block values

        data types to avoid

        derived-type data

        example

        function values

        I/O compatibility

        mechanisms

        passing arguments

        passing target or pointer data

        pointer data

        similarities

    differences from Compaq Fortran 77 for OpenVMS VAX Systems

    external names

        controlling with cDEC$ directives #1

        controlling with cDEC$ directives #2

        controlling with cDEC$ directives #3

    OpenVMS calling standard #1

    OpenVMS calling standard #2

    passing character data between Compaq Fortran and C

Language Sensitive Editor

    diagnostic file

LAPACK routines (Compaq Extended Math Library)

LBR$OUTPUT_HELP

    example use

LEN specifier

    See also LRM

Length

    DOUBLE PRECISION declarations

        qualifiers controlling size

    source line length

        /WARNINGS=TRUNCATED_SOURCE qualifier

    source line length (fixed form)

        /EXTEND_SOURCE qualifier

Length, record

    See Fixed-length records; Variable-length records; Segmented records; Stream records

Lexical tokens per statement

    maximum

LIB$DATE_TIME

    example use

LIB$ESTABLISH

    Compaq Fortran 77 for OpenVMS VAX Systems compatibility

    example use

    general description

LIB$FREE_VM

    example use

LIB$GET_INPUT

    example use

LIB$GET_VM

    example use

LIB$INIT_TIMER

    example use

LIB$MATCH_COND

    example use

LIB$PUT_OUTPUT

    example use

LIB$REVERT

    general description

LIB$SHOW_TIMER

    example use

LIB$SIGNAL

    changing to a stop

    example use #1

    example use #2

    example use #3

    example use #4

    general description

LIB$SIG_TO_RET

LIB$SIG_TO_STOP

LIB$STAT_TIMER

LIB$STOP

    continuing execution after LIB$STOP

    example use #1

    example use #2

    example use #3

    example use #4

    example use #5

    general description

LIB$WAIT

    example use #1

    example use #2

$LIBDEF library module

    in FORSYSDEF

Library

    creating and maintaining

    INCLUDE files

    obtaining information about

    search order

        during compilation

    See also Text file libraries

LIBRARY command

/LIBRARY qualifier

    on FORTRAN command #1

    on FORTRAN command #2

    on LINK command #1

    on LINK command #2

LINK command

    creating image map file

    /DEBUG #1

    /DEBUG #2

    /DEBUG and /TRACEBACK qualifiers

    errors

    for translated shared images

    format

    input file qualifiers

    messages

    options file

        /OPTIONS qualifier

        shared common area (installed shareable image)

        shared common area (mapped global section)

    output file qualifiers

    qualifier summary

    qualifiers and options file use

    sample use with FORTRAN command #1

    sample use with FORTRAN command #2

    symbol table qualifier

$LINK$ program section

    use and attributes

Linker

    FORTRAN option controlling case-sensitive names

    functions performed by

    one or multiple modules in object files (/SEPARATE_COMPILATION)

    options file

    routines with opposition settings

    See also LINK command

LINPACK benchmark

LIS file type

List-directed I/O statements

    Compaq Fortran 77 differences

    See also LRM

/LIST qualifier #1

/LIST qualifier #2

    effect of batch mode

Listing file

    contents

    controlling lines per page

    example requesting listing file #1

    example requesting listing file #2

    requesting

    See also Source code listing

$LITERAL$ program section

    use and attributes

%LOC function

    See also Argument passing

Local processes

    sharing and exchanging data

Logical data type

    converting nonnative data

    declarations and qualifiers

    declaring

    differences with nonnative formats

    ranges

    representation

    See also LRM

    setting default length

    use of all bits

Logical I/O units

    connection method

        implicitly by system default

    default Fortran logical unit numbers

    for preconnected devices

    INQUIRE statement

    OPEN statement options

    See also System logical names

    summary

    system unit numbers and names

Logical names

    associating with file specifications

    commands for setting and unsetting

    converting nonnative numeric data #1

    converting nonnative numeric data #2

    displaying values of

    FOR$ACCEPT

    FOR$ACCEPT, FOR$READ, FOR$PRINT, FOR$TYPE

    FOR$CONVERT.ext #1

    FOR$CONVERT.ext #2

    FOR$CONVERTnnn #1

    FOR$CONVERTnnn #2

    FOR$CONVERT_ext

    FOR$PRINT

    FOR$READ

    FOR$TYPE

    FORnnn #1

    FORnnn #2

    FORnnn #3

    FORT$INCLUDE

    FORT$LIBRARY

    recognized at compile-time

    recognized at run-time

    See also DEFINE command; DEASSIGN command; Logical I/O units

    setting in LOGIN.COM or setting system-wide

    used by OPEN statement

Loop control variable

    and implied-DO loop collapsing

Loop transformation #1

Loop transformation #2

Loops

    and register use

    blocking optimization #1

    blocking optimization #2

    controlling number of times unrolled

    distribution optimization #1

    distribution optimization #2

    efficient coding suggestions #1

    efficient coding suggestions #2

    efficient coding suggestions #3

    efficient coding suggestions #4

    fusion optimization #1

    fusion optimization #2

    interchange optimization #1

    interchange optimization #2

    limiting loop unrolling

    loop transformation optimizations

    optimizations for #1

    optimizations for #2

    optimizations for #3

    outer loop unrolling optimization #1

    outer loop unrolling optimization #2

    scalar replacement optimization #1

    scalar replacement optimization #2

    See also DO loops; Optimization

    software pipelining optimization #1

    software pipelining optimization #2

    software pipelining optimization #3

    software pipelining optimization #4

    transformation optimizations #1

    transformation optimizations #2

    transformation optimizations #3

    transformation optimizations #4

    transformation optimizations #5

Lowercase characters

    option controlling case-sensitive names

LRM

    The acronym LRM in this index refers to the Compaq Fortran Language Reference Manual

M

Machine code listing

    MACRO representation

    output listing section

/MACHINE_CODE qualifier

Mailboxes

    SYS$CREMBX

MAIN option

    program transfer address

Main program

    statements for

MAP file type

MAP parameter

    on LINK command #1

    on LINK command #2

    /SHOW qualifier (FORTRAN command)

/MATH_LIBRARY qualifier

MAXREC specifier

    See also LRM

Mechanism array

    contents and use

Memory

    floating-point formats used (/FLOAT)

    for intermediate storage

    process limits

    system virtual memory limits

    very large (64-bit) access

Message severity

    meaning to compiler

    meaning to linker

    meaning to run-time system

Messages

    compiler-fatal diagnostic messages

    issued by compiler

        general description

        limiting the number

    linker messages

    run-time messages #1

    run-time messages #2

        detecting exceptional values

        displaying online HELP

        displaying secondary system errors

        explanations

        list, condition symbol order

        list, numeric order

    See also Message severity; Warning messages

    source program diagnostic messages

    warning and error

        /SEVERITY qualifier

    warning and informational

        changing severity to error (/SEVERITY)

        /STANDARD qualifier

        /WARNING qualifier

Minus zero (IEEE) handling

Misaligned data

    See also Unaligned data; Alignment

Mixed real/complex operation

/MODULE qualifier

MODULE statement #1

MODULE statement #2

MODULE statement #3

    See also LRM

Modules

    accessing module variables in debugger #1

    accessing module variables in debugger #2

    compiler use of process open file limit

    creating with FORTRAN command

    declaration example

    example compilation

    F90$MOD file type

    files created and used by compiler

    See also LRM

    subprograms

    to contained subprograms

    use association

    use of VOLATILE statement for module variables

    using with FORTRAN command

        specifying object file

$MTHDEF library module

    in FORSYSDEF

N

$NAMDEF library module

    in FORSYSDEF

Name length, symbolic

    maximum

Name (NAM) block

    general description of use

NAME specifier

    See also LRM

Namelist I/O statements

    Compaq Fortran 77 differences

    See also LRM

/NAMES qualifier

NaN values (IEEE)

    /CHECK qualifier

    detecting #1

    detecting #2

    detecting #3

    /IEEE_MODE qualifier

    ISNAN intrinsic function

    representation in Alpha floating-point data

    See also ISNAN intrinsic

/NATIVE_ONLY qualifier (LINK) #1

/NATIVE_ONLY qualifier (LINK) #2

/NATIVE_ONLY qualifier (LINK) #3

Natural boundaries (alignment)

    definition of

    See also Alignment

Natural storage order (arrays)

Nesting limits

    source code

Networking environments

    sharing and exchanging data in

NML specifier

    See also LRM

Nodes

    file specification default

/NOG_FLOATING qualifier (obsolete)

/NOI4 qualifier (obsolete)

Nonadvancing I/O

/NOOPTIMIZE qualifier

    effect on debugging

NOSPANBLOCKS specifier

Null-terminating string

    CHAR intrinsic procedure

Numeric range

    See Data type

Numerical data

    output of

O

OBJ file type #1

OBJ file type #2

Object code listing

    See Machine code listing

Object files

    effect of optimization level on size #1

    effect of optimization level on size #2

    effect of optimization level on size #3

    effect of /SEPARATE_COMPILATION qualifier

    naming

        /OBJECT qualifier

    obtaining information about

    one or multiple modules in

        /SEPARATE_COMPILATION qualifier

    prevent creation of

    See also Compilation options

    with module files

        when needed on FORTRAN command line

/OBJECT qualifier #1

/OBJECT qualifier #2

/OBJECT qualifier #3

OLB file type

/OLD_F77

Open file limit

    increasing number per process

Open operations

    opening a file using RMS

    user-written

        See USEROPEN routines

OPEN statement

    access mode

    ACCESS specifier #1

    ACCESS specifier #2

    ACTION specifier

    APPEND specifier #1

    APPEND specifier #2

    ASSOCIATEVARIABLE specifier

    BLANK specifier

    BLOCKSIZE specifier #1

    BLOCKSIZE specifier #2

    BUFFERCOUNT specifier #1

    BUFFERCOUNT specifier #2

    CARRIAGECONTROL specifier

    CONVERT specifier #1

    CONVERT specifier #2

    CONVERT specifier #3

    DEFAULTFILE specifier #1

    DEFAULTFILE specifier #2

    DEFAULTFILE specifier #3

    DEFAULTFILE specifier #4

    DEFAULTFILE specifier #5

    defaults

        converting nonnative data

        See LRM

        units for preconnected files

    DELIM specifier

    directory and file name defaults

    DISPOSE specifier #1

    DISPOSE specifier #2

    effect of opening previously open file

    ERR specifier

        example

    error handling example

    EXTENDSIZE specifier

    file organization

    file-sharing parameters

    FILE specifier #1

    FILE specifier #2

    FILE specifier #3

    FILE specifier #4

        example

    file status

    FORM specifier #1

    FORM specifier #2

    I/O statement interdependencies #1

    I/O statement interdependencies #2

        file specification

    implied and explicit file open

    importance of examining defaults

    INITIALSIZE specifier

    IOSTAT specifier

        example

    KEY specifier

    MAXREC specifier

    NAME specifier

    NOSPANBLOCKS specifier

    ORGANIZATION specifier #1

    ORGANIZATION specifier #2

    PAD specifier #1

    PAD specifier #2

    POSITION specifier #1

    POSITION specifier #2

    qualifier controlling BLANK specifier default (/NOF77)

    qualifier controlling STATUS specifier default (/NOF77)

    READONLY specifier

    RECL specifier #1

    RECL specifier #2

        and record data transfer #1

        and record data transfer #2

        for fixed-length records

        for variable-length records

        obtaining value for unformatted files

        qualifier to specify units

        units #1

        units #2

    RECORDSIZE specifier

    RECORDTYPE specifier

    See also LRM

    SHARED specifier #1

    SHARED specifier #2

    specifiers for efficient I/O #1

    specifiers for efficient I/O #2

    specifiers identifying

        error handling capabilities

        file access and position

        file allocation

        file and record characteristics

        file and unit

        file close action

        record transfer characteristics

    specifying file specification

    STATUS specifier #1

    STATUS specifier #2

    STATUS specifier #3

    summary of specifiers

    TYPE specifier

    UNIT specifier #1

    UNIT specifier #2

    UNIT specifier #3

    UNIT specifier #4

    use with USEROPEN routines

    USEROPEN specifier

    using preconnected files

OPENED specifier

    See also LRM

OpenVMS calling standard

    argument lists

    argument-passing mechanisms

    general calling considerations

    OpenVMS data types

    register and stack usage

OpenVMS Debugger

    See Debugger

OpenVMS library routines

    See RTL; LIB$name

OpenVMS RMS

    See RMS

OpenVMS system services

    See SYS$name; System services

OpenVMS Web site

Operations

    mixed real/complex

Operators

    arithmetic

        for efficient run-time performance

    See also LRM

OPT file type

Optimization #1

Optimization #2

    additional global

    and performance measurement

    automatic inlining

    code hoisting

    code replication to eliminate branches

    common subexpression elimination

    compile-time operations

    compiler option summary

    compiling multiple files for efficient run-time performance

    constant pooling

    controlling procedure inlining

    data-flow and split lifetime analysis

    dead code

    dead store elimination (unused variables)

    effect on

        compilation time

        debugging

        object file size

        output file size

        program execution

    for specific Alpha processor generation #1

    for specific Alpha processor generation #2

    global

    implied DO loop collapsing #1

    implied DO loop collapsing #2

    inline expansion

    inlining procedures #1

    inlining procedures #2

    instruction scheduling #1

    instruction scheduling #2

    instruction scheduling #3

    instruction scheduling #4

    instruction scheduling #5

    interprocedure analysis

    level

    limiting loop unrolling

    local

    loop blocking #1

    loop blocking #2

    loop distribution #1

    loop distribution #2

    loop fusion #1

    loop fusion #2

    loop interchange #1

    loop interchange #2

    loop outer loop unrolling #1

    loop outer loop unrolling #2

    loop scalar replacement #1

    loop scalar replacement #2

    loop transformation #1

    loop transformation #2

    loop transformation #3

    loop transformation #4

    loop transformation #5

    loop unrolling

    loops #1

    loops #2

    mixed real/complex operations

    multiplication and division expansion

    of loops

    of statement functions and intrinsics

    /OPTIMIZE=INLINE=keyword

    /OPTIMIZE qualifier

        INLINE=keyword

        LEVEL=n

        LOOPS

        PIPELINE

        TUNE=keyword

        UNROLL=n

    /OPTIMIZE=TUNE=keyword

    /OPTIMIZE=UNROLL=n

    overview of levels

    qualifiers for #1

    qualifiers for #2

        summary

    register use

    removal optimizations

    reordering floating-point operations

    software pipelining #1

    software pipelining #2

    software pipelining #3

    software pipelining #4

    source code guidelines for (check list)

    summary of /OPTIMIZE=LEVEL=n

    to reduce program size (space optimizations) #1

    to reduce program size (space optimizations) #2

    using dummy aliases

    value propagation

Optimization techniques, user

    adjustments to process working set

/OPTIMIZE qualifier

    INLINE=keyword #1

    INLINE=keyword #2

    LEVEL=n #1

    LEVEL=n #2

    LOOPS

    NOINLINE

    PIPELINE

    TUNE=keyword #1

    TUNE=keyword #2

    UNROLL=n #1

    UNROLL=n #2

    UNROLL=n #3

OPTIONS (MAIN)

    as program transfer address

/OPTIONS qualifier (LINK) #1

/OPTIONS qualifier (LINK) #2

OPTIONS statement

    See also LRM

    specifying unformatted file floating-point format

    use

Order of subscript progression

    in I/O

ORGANIZATION specifier #1

ORGANIZATION specifier #2

    See also LRM

Output listing

    compilation summary section

    lines per page

    machine code section

    See also Compilation options

    storage map section

Output, screen

    formatting example

Overflow

    array bounds

    floating-point

    integer #1

    integer #2

    See also Arithmetic exception handling

P

PAD specifier #1

PAD specifier #2

    See also LRM

/PAD_SOURCE qualifier

Page fault

    and temporary storage

Parallel processing

    KAP preprocessor

PARAMETER statement

    compiler option for alternate PARAMETER syntax

    See also LRM

Parentheses in expressions

    maximum allowed

Passed-length character arguments

    See also LRM

Performance

    /ALIGNMENT qualifier

    arithmetic operators and run-time performance

    array use efficiency #1

    array use efficiency #2

    /ASSUME=DUMMY_ALIASES qualifier #1

    /ASSUME=DUMMY_ALIASES qualifier #2

    /ASSUME=NOACCURACY_SENSITIVE qualifier #1

    /ASSUME=NOACCURACY_SENSITIVE qualifier #2

    /ASSUME qualifier

    checking

        for unaligned data #1

        for unaligned data #2

        process limits #1

        process limits #2

    choosing optimal record type

    compilation #1

    compilation #2

    compilation times and optimization levels

    controlling procedure inlining

    data alignment efficiency #1

    data alignment efficiency #2

    data types and run-time performance #1

    data types and run-time performance #2

    DO loop coding and run-time performance

    effect of formatted files on run-time performance

    equivalence and run-time performance

    internal subprograms and run-time performance

    limiting loop unrolling

    measuring

        Compaq Fortran intrinsic procedures

        LIB$xxxx_TIMER routines

        optimized programs

        Performance and Coverage Analyzer

        using command procedures

    mixed data type operations and run-time performance

    OPEN statement specifiers for efficient I/O

    optimization for Alpha processor generation #1

    optimization for Alpha processor generation #2

    optimization levels

    /OPTIMIZE qualifier

    profiling code

    qualifiers

        controlling code generation (/ARCHITECTURE)

        controlling optimizations #1

        controlling optimizations #2

        data alignment efficiency

        dummy alias assumption

        floating-point calculations

        for run-time efficiency

        math library use

        selecting floating-point data types

        summary

        that improve performance

        that slow performance

    realistic measurements

    record I/O buffers #1

    record I/O buffers #2

    redirecting scrolled output and run-time performance

    reordering floating-point operations

    run-time #1

    run-time #2

        I/O efficiency

    selecting floating-point data types

    size of INTEGER and LOGICAL data

    source code guidelines for run-time efficiency

    statement functions and run-time performance

    timings

Performance and Coverage Analyzer (PCA)

Pointers

    C language

    effect of explicit interface

    passed between Compaq Fortran and C #1

    passed between Compaq Fortran and C #2

    passing as arguments

    passing between C and Compaq Fortran

    See also LRM

    use with Compaq Fortran 77

Porting information

    See Compatibility

POSITION specifier #1

POSITION specifier #2

    See also LRM

Precision

    floating-point data types

Preconnected files

    I/O statements

    OPEN statement

Preprocessor

    improving run-time performance (KAP)

Primary key fields (indexed files)

    definition

PRINT statement

    See also LRM

Procedure-based signal handling

    See CHF

Procedure-calling standard (OpenVMS)

Procedure interface

    argument passing rules

    array arguments

    changing default passing mechanisms #1

    changing default passing mechanisms #2

    Compaq Fortran 77 and Compaq Fortran

        passing arguments

    Compaq Fortran and C #1

    Compaq Fortran and C #2

    Compaq Fortran array descriptor format

    Compaq Fortran subprograms

    explicit interface #1

    explicit interface #2

    explicit interface #3

    explicit interface #4

    implicit interface

    modules #1

    modules #2

    pointer arguments

    procedure interface block #1

    procedure interface block #2

    See also LRM

    types of subprograms

Procedure signature block (PSB)

Procedures

    analyzing performance

    inlining #1

    inlining #2

    inlining #3

    inlining #4

    inlining #5

    inlining #6

        compiling multiple files

    run-time

        linking

    See also LRM

    types of subprograms

Process

    creation and management of

    example of adjusting process memory limits

    for large programs

    interprocess communication

        example

    limits

        checking #1

        checking #2

        increasing memory-limiting SYSGEN parameters

        increasing memory size

        increasing open file limit

    sharing and exchanging data #1

    sharing and exchanging data #2

Profiling code

    command procedures

    LIB$xxxx_TIMER routines

    PCA

Program

    compiling #1

    compiling #2

    compiling (example)

    execution

    linking (example)

    name

        default in debugger

    section #1

    section #2

        mapped global pagefile section

        shareable common area

    See also Executable program

    size

        effect of optimization levels

        limitations

        process memory size

        space optimizations

    threaded execution

        related qualifiers

    transportability

        See Compatibility

    units

        creating modules for

Program counter (PC)

Program section (PSECT)

    attributes in listing file

    changing attributes #1

    changing attributes #2

    characteristics

    compile-time attributes

    link-time attributes (LINK/MAP)

    mapped global pagefile section

    shareable common area

PROGRAM statement #1

PROGRAM statement #2

    See also LRM

Program transportability

    data

Prompt

    debugger (DBG>)

Protection control block

    XABPRO (RMS)

PSECT

    See Program section (PSECT)

Q

QIO services

    example use

    See also SYS$QIOW

Qualifier names

    abbreviating

    See also Compiler options

Quotation mark character

    See also LRM

R

RAB

    See Record access block

$RABDEF library module

    in FORSYSDEF

RAN function (compatibility)

    See also LRM

Random number generation (Compaq Extended Math Library)

Ranges

    for complex constants

    for integer constants

    for logical constants

    for real constants

Read operations

    See I/O operations

READ statement

    ADVANCE specifier

    See also LRM

READONLY specifier

    See also LRM

Real data types #1

Real data types #2

Real data types #3

    declarations and qualifiers

    native representation

    ranges #1

    ranges #2

    See also LRM

    VAX representation

REAL declarations

    option to control size of

Real exponentiation (/CHECK)

REAL intrinsic function

    See LRM

/REAL_SIZE qualifier

REC specifier

    See also LRM

RECL specifier

    for fixed-length records

    for variable-length records

    INQUIRE statement

        /ASSUME=BYTERECL qualifier

    obtaining value for unformatted files

    OPEN statement

        /ASSUME=BYTERECL qualifier

    qualifier to specify units

    See also LRM

    units for formatted files

    units for unformatted files

Record

    length

        INQUIRE statement

        See also RECL specifier

    locking

    memory diagrams of

Record Access Block (RAB)

    fields for use by USEROPEN

    general description of use

    obtaining address of

Record access mode #1

Record access mode #2

    available for file organizations

    direct #1

    direct #2

    direct access to sequential files

    for indexed sequential files

    keyed #1

    keyed #2

    limitations by file organizations and record types

    OPEN statement specifiers #1

    OPEN statement specifiers #2

    sequential

Record arrays

    output listing information

    See also Array

Record I/O

    ADVANCE specifier

    advancing

    amount of data transferred by I/O statements

    available I/O statements and forms

    buffers and disk I/O #1

    buffers and disk I/O #2

    buffers and disk I/O #3

    buffers and disk I/O #4

    data transfer

    deleting records from a file (DELETE)

    END branch specifier

    EOR branch specifier

    flushing buffers

    in internal files

    indexed file record pointers (current and next)

    length

        effect on performance

        obtaining using INQUIRE (unformatted)

        See also LRM

    nonadvancing

    performance

    position

    record operations on indexed files

    record types

    See also I/O; LRM

    SIZE branch specifier

    statement specifiers

Record length value

    qualifiers

        byte record length value assumption

Record locking

    RMS facility

Record Management Services (RMS)

    data structures

        constructed by RTL

        FAB

        field use by USEROPEN

        list of

        NAM

        RAB

        steps to using

        use by USEROPEN

        XAB

    error signaling

        example

    example of calling

    file sharing capability

    output record buffering

    overview of how to use RMS services

    pointers into indexed files

    record locking facility #1

    record locking facility #2

RECORD statement

    causes of misalignment

    data alignment #1

    data alignment #2

    See also LRM

Record structures

    accessing variables in debugger

    alignment of

    order of data in

    qualifiers controlling alignment #1

    qualifiers controlling alignment #2

    See also LRM

    storage of

Record type

    available file organizations

    choosing for optimal run-time performance

    converting nonnative data

        OPEN statement defaults

        See also LRM

    declaring

        RECORDTYPE specifier

        See also LRM

    fixed-length

    obtaining

        INQUIRE statement

    portability considerations

    segmented

    stored in file header

    stream

    stream_CR

    stream_LF

    variable-length

Records

    output listing information

    record types

    See also Record type; RECORD statement

    structured data items

        data alignment

RECORDTYPE specifier

    See also LRM

Recovery unit control block

    XABRU (RMS)

Recursion

    qualifier controlling

    See also LRM

/RECURSIVE qualifier

Reentrancy

    asynchronous

        RTL behavior

    RTL calls

        qualifier controlling

    threaded

        RTL behavior

/REENTRANCY qualifier

Reentrant program

    threaded execution

%REF function

    See also Argument passing

References

    See also LRM

    unresolved (Linker)

Register usage

    array index

    effect of optimization

    effect of VOLATILE statement

    holding variables

    loops that exhaust available registers #1

    loops that exhaust available registers #2

    loops that exhaust available registers #3

    on OpenVMS Alpha systems

Relational operators

    See also LRM

Relative file

    general description

    record access modes for

    record types for

    See also Direct access mode

    See also LRM

    specifying

    specifying RECL when creating

Remote file access

Remote processes

    sharing and exchanging data

Removal optimizations #1

Removal optimizations #2

RESHAPE intrinsic procedure

Resultant String Area (RSA)

    RMS control structure #1

    RMS control structure #2

RETURN statement

    when not to use

Return values, function

Returning completion status values

    to a command procedure

Revision date and time control block

    XABRDT (RMS)

REWIND statement #1

REWIND statement #2

    See also LRM

REWRITE statement

    See also LRM

RMS

    See Record Management Services (RMS)

$RMSDEF library module

Rounding modes

    IEEE floating-point calculations

/ROUNDING_MODE qualifier

RSA

    See Resultant string area (RSA)

RTL

    See Run-Time Library (RTL)

RUN command (DCL) #1

RUN command (DCL) #2

    continuing

    effect of /DEBUG #1

    effect of /DEBUG #2

    interrupting

Run-time call stack

    See Call stack

Run-Time Library (RTL)

    and implied-DO loop collapsing #1

    and implied-DO loop collapsing #2

    error processing performed by

    Fortran I/O support routines

        used as result of USEROPEN

    general calling considerations

    OpenVMS data types

    overview of library routines

    requesting threaded execution

    See also LIB$name

    using latest version for run-time efficiency

Run-time messages

    description of each

    displaying secondary system errors

    format

    format mismatches

    format truncation

    handling

    list, number sequence

    severity levels

    using online help

Run-time procedures

    linking

S

Scratch files

    See also LRM

SCRATCH specifier

    See also LRM

Screen management subroutines

    examples

    See also SMG$name

Screen output

    formatting example

Segmented records

    portability considerations

/SELECTIVE_SEARCH qualifier (LINK)

/SEPARATE_COMPILATION qualifier

SEQUENCE statement

    derived-type data order #1

    derived-type data order #2

    derived-type data order #3

    derived-type data order #4

    See also LRM

Sequential access

Sequential access mode

    for indexed organization files

    optimal record types

Sequential file

    general description

    record access modes for

    record types for

    requirements for direct access mode

    See also LRM

    specifying

/SEVERITY qualifier

Shareable image

    common area (interprocess communication)

    creating

    debugger commands

    input to linker #1

    input to linker #2

    installing

    libraries

        benefits

        creating and installing

        general discussion

        input to linker #1

        input to linker #2

    program section (PSECT) attribute #1

    program section (PSECT) attribute #2

/SHAREABLE qualifier (LINK) #1

/SHAREABLE qualifier (LINK) #2

/SHAREABLE qualifier (LINK) #3

Shared memory access

    granularity

    installed common areas

    mapped global pagefile section

    requesting threaded program execution

    See also VOLATILE statement

SHARED specifier #1

SHARED specifier #2

    See also LRM

Sharing data

    See Data; File sharing; Shared memory access

Sharing files

    OPEN statement

    See also File sharing

SHOW LOGICAL command (DCL)

    viewing logical names

/SHOW qualifier

    ALL keyword

    INCLUDE keyword

    MAP keyword

    NONE keyword

Signal array

    contents and use

Signal handling routines

    See Condition-handler routines

Signal processing routines (Compaq Extended Math Library)

Signals, condition

    changing to return status

        LIB$SIG_TO_RET

SIZE branch specifier

SIZE specifier

    See LRM

SIZEOF function

    example use

    using

        See LRM

SMG$CREATE_PASTEBOARD

    example use

SMG$CREATE_VIRTUAL_DISPLAY

    example use

SMG$LABEL_BORDER

    example use

SMG$PASTE_VIRTUAL_DISPLAY

    example use

SMG$PUT_LINE

    example use

SMG routines

    examples

SNGL intrinsic function

    qualifier controlling size returned

    See also LRM

Software pipelining #1

Software pipelining #2

Sorting (Compaq Extended Math Library)

Source code

    checking standards conformance of

    coding restrictions

    columns

        See LRM

    D in column 1 (/D_LINES)

    diagnostic messages

    file type conventions

    include files

    include text library modules

    limits

    lines

        pad with spaces

    listing

        controlling contents of (/MACHINE_CODE)

        controlling contents of (/SHOW)

        general description

        requesting (/LIST)

    maximum line length (fixed form)

    module files

    option controlling case-sensitive names

    questionable

        controlling warning message

    See also Source lines; Source code listing

    source forms

Source Code Analyzer

    analysis file

Source files

    building using OpenVMS tools

    creating and revising #1

    creating and revising #2

    input to compiler

    managing

Source form

    file types recognized #1

    file types recognized #2

    fixed-form source compiler options #1

    fixed-form source compiler options #2

    fixed-form source compiler options #3

    qualifiers for specifying

    See also LRM

Source lines

    coding restrictions

    continuation character

        See LRM

    controlling in listing file (/SHOW)

    controlling messages in listing file (/STANDARD)

    controlling truncation messages (/WARNINGS)

    D in column 1 (/D_LINES)

    extending length (fixed form)

    form-feed effect on listing file

Source programs

    compile options

        detecting truncated lines

/SOURCE_FORM qualifier

Sparse linear system routines (Compaq Extended Math Library)

Specifier options (Fortran)

    See I/O statements; LRM

SQRT function

    example use

SS$_CONTINUE

    use in condition handlers

SS$_RESIGNAL

    use in condition handlers

$SSDEF library module

    in FORSYSDEF

Standard I/O file

    I/O statements default use

/STANDARD qualifier

Standards

    ANSI FORTRAN-77 and FORTRAN 66 #1

    ANSI FORTRAN-77 and FORTRAN 66 #2

    Fortran 90

        checking (/STANDARD)

    Fortran 95

        checking (/STANDARD)

Statement functions

    efficient run-time performance

    in data-flow analysis

    inline expansion of

    never called

        controlling warning messages

    See also LRM

Statement labels

    output listing information

    See also LRM; Labels; Source code

Statements

    continuation character

        See LRM

    maximum line length (fixed form)

    truncation during compilation

STATUS specifier

    See also LRM

Status values, completion

    returning to a command procedure

STB file type

STOP command (DCL)

STOP statement

    effect on program execution

    when not to use

Storage map listing

    general description

Stream (Stream_CRLF) records

Stream_CR records

    portability considerations

Stream_LF records

    portability considerations

    use for optimal performance

STRUCTURE statement

    and data alignment

    causes of misalignment

    See also LRM

Structures

    nesting limit

    See also Derived-types data; Record structures; LRM

Subprogram

    arguments #1

    arguments #2

        C and Fortran #1

        C and Fortran #2

        See also LRM

    Compaq Fortran 77 and Compaq Fortran

    definition of

    explicit interface

    external

    inlining #1

    inlining #2

    inlining #3

        compiling multiple files

    internal (host association)

    module (use association)

    passing arguments and function return values #1

    passing arguments and function return values #2

    procedure interface block

    requiring a procedure interface block for explicit interface

    See also LRM; Procedure interface

    types of

Subroutine calls

    between Compaq Fortran and C

    in data-flow and split lifetime analysis

SUBROUTINE statement

    See also LRM

Subroutines

    declaration statements

    explicit interface

    output listing information

    See also LRM

Substring references

    checking boundaries

        FORTRAN command option

SUM intrinsic

Summary control block

    XABSUM (RMS)

Summary listing, compilation

Symbol

    records (DEBUG)

Symbol map

    /SHOW qualifier

        affect of MAP parameter

Symbol table

    created by compiler #1

    created by compiler #2

        /DEBUG qualifier

    created by linker

        /DEBUG qualifier

    overview of creation and use

Symbolic names

    maximum length

    See also LRM; FORSYSDEF

/SYMBOL_TABLE qualifier (LINK) #1

/SYMBOL_TABLE qualifier (LINK) #2

Synchronizing access

    system routines for

Synchronous I/O

    accessing devices using SYS$QIOW

/SYNCHRONOUS_EXCEPTIONS qualifier

/SYNTAX_ONLY qualifier

SYS$ADJWSL

    example use

SYS$ASCEFC

    example use

SYS$ASSIGN

    example use #1

    example use #2

    example use #3

SYS$CLOSE (RMS)

    data structure needed to use

SYS$CONNECT (RMS)

    data structure needed to use

    use to open a file #1

    use to open a file #2

        example of

SYS$CREATE (RMS)

    data structure needed to use

    use to open a file

        example of #1

        example of #2

SYS$CREMBX

    example use

SYS$CREPRC

    example use

SYS$CRMPSC

    example use

SYS$DELETE (RMS)

    data structure needed to use

SYS$DEQ

    synchronizing access

SYS$DISCONNECT (RMS)

    data structure needed to use

SYS$DISPLAY (RMS)

    data structure needed to use

SYS$ENQ

    synchronizing access

SYS$ENTER (RMS)

    data structure needed to use

SYS$ERASE (RMS)

    data structure needed to use

SYS$EXTEND (RMS)

    data structure needed to use

SYS$FIND (RMS)

    data structure needed to use

SYS$FLUSH (RMS)

    data structure needed to use

    output record buffering

SYS$FREE (RMS)

    data structure needed to use

SYS$GET (RMS)

    data structure needed to use

SYS$GETJPIW

    example use #1

    example use #2

SYS$HIBER

    example use

    synchronizing access

SYS$INPUT

    default logical unit number #1

    default logical unit number #2

SYS$LIBRARY

SYS$LP_LINES

    redefining

SYS$MGBLSC

    example use

SYS$NXTVOL (RMS)

    data structure needed to use

SYS$OPEN (RMS)

    data structure needed to use

    example of use

    when to use

SYS$OUTPUT

    default logical unit number #1

    default logical unit number #2

SYS$PARSE (RMS)

    data structure needed to use

SYS$PUT (RMS)

    data structure needed to use

SYS$QIO

    example use

SYS$QIOW

    example use #1

    example use #2

    example use #3

    example use #4

    See also QIO

SYS$READ (RMS)

    data structure needed to use

    example of use

SYS$RELEASE (RMS)

    data structure needed to use

SYS$REMOVE (RMS)

    data structure needed to use

SYS$RENAME (RMS)

    data structure needed to use

SYS$REWIND (RMS)

    data structure needed to use

SYS$SEARCH (RMS)

    data structure needed to use

SYS$SETDDIR

    example use

SYS$SETEF

    example use

SYS$SETEXV

SYS$SPACE (RMS)

    data structure needed to use

SYS$TRNLNM

    example use #1

    example use #2

SYS$TRUNCATE (RMS)

    data structure needed to use

SYS$UNWIND

    use in condition handlers

SYS$UPDATE (RMS)

    data structure needed to use

SYS$WAIT (RMS)

    data structure needed to use

SYS$WAITFR

    example use

SYS$WAKE

    example use

    synchronizing access

SYS$WRITE (RMS)

    data structure needed to use

    example of use

/SYSLIB qualifier (LINK)

/SYSSHR qualifier (LINK)

System definition library modules

System services

    closing file

    example programs using

    flushing record buffers

    functional groups

    general calling considerations

    opening file

    OpenVMS data types

    overview

    record operations

    See also SYS$name

    summary of RMS services

    used for synchronizing access

    used in condition handler routines

System symbols

    conventions in FORSYSDEF

        PARAMETER declarations

S_float data

    See Floating-point data types

T

Task-to-task communications, network

Terminal control block

    XABTRM (RMS)

Terminal I/O

    Compaq Fortran 77 differences

    example of SYS$QIOW

    formatting screen output

    interrupting interactive program execution

        example of handling Ctrl/C #1

        example of handling Ctrl/C #2

    See also Ctrl/C; Ctrl/Y

Text file libraries

    creating and modifying

        LIBRARY command

    defining defaults

    general discussion

    INCLUDE searches

    /LIBRARY qualifier

    search order (compilation)

    specifying

        on command line (/LIBRARY)

    system-supplied default library

        FORSYSDEF.TLB

Thread locking

    reentrancy during RTL calls

Threaded program execution

    related qualifiers

    requesting

Threaded reentrancy

    effect on RTL

/TIE qualifier #1

/TIE qualifier #2

TLB file type #1

TLB file type #2

Traceback condition handler

Traceback mechanism

    effect of /DEBUG

        on LINK command #1

        on LINK command #2

        on LINK command #3

    effect of /DEBUG qualifier

/TRACEBACK qualifier (LINK) #1

/TRACEBACK qualifier (LINK) #2

/TRACEBACK qualifier (LINK) #3

Translated images interoperability

    FORTRAN command #1

    FORTRAN command #2

    LINK command #1

    LINK command #2

    LINK command #3

    summary

Transportability

    See also Compatibility; Data; Record types; Unformatted files

TYPE specifier

    See also LRM

TYPE statement

    See also LRM

T_float data

    See Floating-point data types

U

UBOUND intrinsic

Unaligned data

    causes

    checking for

    compiler

    derived-type

        effect of SEQUENCE statement

    error messages

        compiler

        run-time

    using debugger to locate

Underflow

    controlling handling (/IEEE_MODE qualifier)

    denormalized numbers #1

    denormalized numbers #2

    run-time checking (/CHECK)

    See also Denormalized numbers (IEEE)

Unformatted data

    and DO loop collapsing

    and nonnative numeric formats #1

    and nonnative numeric formats #2

    efficient run-time performance

    I/O statements for

    inquiry by output item list

Unformatted files

    converting nonnative data

        record type

    methods of specifying the format

    specifying format

    specifying record type

    supported numeric formats #1

    supported numeric formats #2

    using command qualifier to specify RECL units

    using FORTRAN /CONVERT qualifier to specify format

    using logical name method to specify format #1

    using logical name method to specify format #2

    using OPEN Statement CONVERT='keyword' method to specify format

    using OPTIONS statement /CONVERT to specify format

Unformatted I/O statements

    See also LRM

UNIT specifier #1

UNIT specifier #2

UNIT specifier #3

    See also LRM

Units, logical I/O

    See Logical I/O units

UNLOCK statement #1

UNLOCK statement #2

    See also LRM

Unresolved references

Unwind operations

    See also SYS$UNWIND

USE statement #1

USE statement #2

USE statement #3

    See also LRM

User-defined data types

    See Derived-type data

User-written open procedures

    See USEROPEN routines

/USERLIBRARY qualifier (LINK)

USEROPEN routines

    block mode I/O example

    description of use

    in-depth discussion of

    restrictions on use

USEROPEN specifier

    See also LRM

Utility routines (Compaq Extended Math Library)

V

%VAL function

    See also Argument passing

Value propagation #1

Value propagation #2

Variable format expression

    See also LRM

Variable-length records

    use for optimal performance

Variables

    alignment

    assigned but never used

    declared but not used

        controlling warning message

    never declared

        controlling warning messages

    output listing information

    See also LRM

    used before value assigned

        controlling warning message

Variables declared in other languages, accessing

VAX FORTRAN

    See Compaq Fortran 77; VAX systems

VAX systems

    Compaq Fortran 77 (OpenVMS)

        H_float data representation

    converting data to IEEE formats #1

    converting data to IEEE formats #2

    floating-point data

        COMPLEX

        COMPLEX*16

        converting #1

        converting #2

        D_float

        F_float

        G_float

        H_float

Vector mathematics (Compaq Extended Math Library)

Version number

    obtaining from command line

    obtaining from listing file

/VERSION qualifier

Very Large Memory (cDEC$ ATTRIBUTES ADDRESS64 directive)

Virtual memory

    64-bit (cDEC$ ATTRIBUTES ADDRESS64 directive)

    allocating (LIB$GET_VM)

    deallocating (LIB$FREE_VM)

    system and process limits

VMS

    See OpenVMS

/VMS qualifier

VOLATILE statement

    and data-flow and split lifetime analysis

    and granularity

    and implied-DO loop collapsing

    See also LRM

    use with %LOC

    use with shared memory access

    when to use

W

Warning messages

    argument mismatches

    arithmetic exception handling (run-time)

    changing severity of (/SEVERITY)

    controlling all messages

    data granularity

    exceptional values at run-time (/CHECK)

    flagging Compaq extensions as error severity (/SEVERITY)

    flagging Compaq extensions (/STANDARD)

    floating-point underflow at run-time (/CHECK)

    floating-point underflow at run-time (/CHECK)

    format mismatches at run-time (/CHECK)

    format truncation mismatches at run-time (/CHECK)

    integer overflow at run-time (/CHECK)

    limiting at compile-time (/ERROR_LIMIT)

    misalignment (compile-time)

    misalignment (run-time)

    nonprinting ASCII characters

    questionable programming practices

    standards conformance (/STANDARD)

    statement functions never called

    substring references at run-time (/CHECK)

    truncated lines

    undeclared variable use

    unused, declared variables

    use of two-digit year by intrinsic functions

    variables used before value assigned

    year 2000 (two-digit year)

/WARNINGS=ALIGNMENT qualifier

/WARNINGS=ALL qualifier

/WARNINGS=ARGUMENT_CHECKING qualifier

/WARNINGS=DECLARATIONS qualifier

/WARNINGS=GENERAL qualifier

/WARNINGS=GRANULARITY qualifier

/WARNINGS=IGNORE_LOC qualifier

/WARNINGS=NONE qualifier

/WARNINGS qualifier

/WARNINGS=UNCALLED qualifier

/WARNINGS=UNINITIALIZED qualifier

/WARNINGS=UNUSED qualifier

/WARNINGS=USAGE qualifier

Web site

    OpenVMS

Working set, process

    example of how to adjust

Write operations

    See I/O operations

WRITE statement

    ADVANCE specifier

    See also LRM

X

X edit descriptor

    See also LRM

XAB

    See Extended access block (XAB)

XABALL (RMS)

    allocation control block

XABDAT (RMS)

    date and time control block

XABFHC (RMS)

    file header characteristics control block

XABITM (RMS)

    item list control block

XABJNL (RMS)

    journaling control block

XABKEY (RMS)

    key definition control block

XABPRO (RMS)

    protection control block

XABRU (RMS)

    recovery unit block

XABSUM (RMS)

    summary control block

XABTRM (RMS)

    terminal control block

Z

Zero

    representation in Alpha floating-point data

ZEXT function #1

ZEXT function #2

    See also LRM