3f library routines (U*X on RISC)

 DEC Fortran library routines (in reference page section 3f) that
 handle the various differences between DEC Fortran and C in
 argument passing and data types.  Some 3f routines are language
 interface routines that make appropriate system calls or call
 library routines.  You can call these routines from DEC Fortran
 programs.  For a list of 3f routines, see the intro(3f) reference
 page.

 absolute pathname (U*X)

 A directory path specified in fixed relationship to the root
 directory; the first character is a slash (/).

 actual argument

 A value passed from a calling program unit to a subprogram.

 aggregate reference

 A reference to a record field that resolves into a reference to a
 structured data item (a record structure or substructure).

 alphabetic character

 A letter of the alphabet (uppercase A through Z and lowercase a
 through z).

 Pertaining to letters, digits and other special characters, such as
 punctuation marks and mathematical symbols (for example, plus and
 minus signs).

 alternate key (VMS)

 An optional key within the data records in an indexed file, which
 can be used to build an alternate index.

 The American National Standards Institute.  An organization through
 which accredited organizations create and maintain voluntary
 industry standards.

 A variable (parameter) passed between a calling routine and a
 called routine.  See also actual_argument and dummy_argument.

 arithmetic expression

 A numeric constant, variable, or function value, or combination of
 these, joined by arithmetic operators and parentheses, so that the
 entire expression can be evaluated to produce a single numeric
 value.  For example, -L or X+(Y-4.5)*Z.

 arithmetic operator

 A symbol designating an arithmetic operation.  In Fortran, the
 symbols +, -, *, /, and ** are used to designate addition,
 subtraction, multiplication, division, and exponentiation,
 respectively.

 A group of components, called elements, that all have the same data
 type and share a common symbolic name.  Components of an array are
 specified individually with subscripts.  See also array element.

 array declaration

 A program statement specifying an array name, the number of
 dimensions it contains, and its dimension bounds.  An array
 declaration can appear in a DIMENSION, COMMON, or explicit type
 statement.  See also array_name.

 array element

 An item in an array, identified by the array name followed by one
 or more subscripts in parentheses, indicating the element's
 position in the array.  For example, B(3) or A(2,5).

 array name

 The symbolic name associated with an array.

 array name reference

 A reference to a record field that resolves into a reference to an
 array.  See also array.

 The American Standard Code for Information Interchange.  A 7-bit
 character encoding scheme associating an integer from 0 through 127
 with 128 characters.  See also multinational_character_set.

 assignment statement

 A statement that assigns (stores) the value of an expression on the
 right of an equal sign to the storage location of the variable to
 the left of the equal sign.

 assumed-size array

 A dummy array whose size is assumed from the associated actual
 argument.  The upper bound of its last dimension is specified by an
 asterisk (*).

 background process (U*X)

 A process for which the command interpreter is not waiting.  Its
 process group differs from that of its controlling terminal, so it
 is blocked from most terminal access.  Contrast with
 foreground_process.

 batch process (VMS)

 A process that runs without user interaction.  Contrast with
 interactive_process.

 binary constant (RISC, AXP)

 A constant that is a string of binary digits (0 or 1) enclosed by
 apostrophes and preceded or followed by the letter B.

 binary operator

 An operator that acts on a pair of operands.  The exponentiation,
 multiplication, division, and concatenation operators are binary
 operators.

 bit constant

 A constant that is an octal or hexadecimal number.  In DEC Fortran,
 it can also be a binary number.

 bit field

 A contiguous group of bits within a binary pattern; they are
 specified by a starting bit position and length.  The functions
 IBSET, IBCLR, BTEST, and IBITS, and the subroutine MVBITS operate
 on bit fields.

 blank common block

 A common block (one or more contiguous areas of storage) without a
 name.  Common blocks are defined by a COMMON statement.

 In general, a group of related items treated as a physical unit.
 For example, a block can be a sequence of program statements that
 perform a specific function, or a set of records accessed as a
 single unit.

 block data subprogram

 A program unit, containing a BLOCK DATA statement and its
 associated specification statements, that establishes common blocks
 and assigns initial values to the variables in named common blocks.

 The slowest process in an executing program.  This process
 determines the maximum speed of execution.

 See dimension_bounds.

 A critical point in a program, during which execution is stopped so
 that you can see if the program variables contain the correct
 values.  Breakpoints are often used to debug programs.

 built-in function

 See intrinsic_function.

 carriage-control character

 A character in the first position of a printed record that
 determines the vertical spacing of the output line.

 character constant

 A constant that is a string of printable ASCII characters enclosed
 by apostrophes (').  In DEC Fortran, the string can alternatively
 be enclosed by quotation marks (").

 character expression

 A character constant, variable, function value, or another constant
 expression, separated by a concatenation operator (//); for
 example, DAY//' FIRST'.

 character string

 A sequence of contiguous characters; a character data value.  See
 also character_constant.

 character substring

 One or more contiguous characters in a character string.

 character storage unit

 The amount of storage needed to represent one scalar character
 value.  In DEC Fortran, one character storage unit is equivalent to
 one byte of memory.

 character type

 A data type consisting of alphanumeric characters.  See also
 data_type.

 Text that documents or explains a program, and begins with a letter
 C (or c) or an asterisk (*) in column 1 of a source line.  Note
 that the letter C can also denote a compiler directive.  A comment
 can also begin with an exclamation point (!), which can appear
 anywhere in a source line -- except in a Hollerith or character
 constant, in column 6 of a fixed-format line, or inside a
 placeholder (using the DESIGN compiler option on VMS on VAX).  The
 comment extends from the exclamation point to the end of the line.
 The Fortran compiler does not process comments, but shows them in
 program listings.  See also compiler_directive.

 common block

 A storage area (area in memory) shared by one or more program
 units.  This storage area is defined by a COMMON statement.  If the
 common block is given a name, it is a named common block; if it is
 not given a name, it is a blank common block.  See also
 blank_common_block.

 compiler directive

 A statement that tells the compiler to perform certain tasks when
 it compiles a source program unit.  The tag CDEC$ (and CPAR$ in VMS
 on VAX) must appear in columns 1 through 5.

 complex constant

 A constant that is a pair of real or integer constants representing
 a complex number; the pair is separated by a comma and enclosed in
 parentheses.  The first constant represents the real part of the
 number; the second constant represents the imaginary part.  In DEC
 Fortran, there are two types of complex constants:  COMPLEX
 (COMPLEX*8) and DOUBLE COMPLEX (COMPLEX*16).

 complex type

 A data type that represents the values of complex numbers.  The
 value is expressed as a complex constant.  See also data_type.

 The combination of two items into one by placing one of the items
 after the other.  In Fortran, the concatenation operator (//) is
 used to combine character items.  See also character_expression.

 conservative automatic inlining

 The inline expansion of small procedures, with conservative
 heuristics to limit extra code.

 A data item with a fixed value that does not change during the
 execution of a program.  The value of a constant can be numeric or
 logical, or it can be a character string.  Contrast with variable.

 Pertaining to entities that are adjacent (next to one another)
 without intervening spaces:  for example, contiguous characters or
 contiguous areas of storage.

 control statement

 A statement that alters the normal order of execution by
 transferring control to another section of a program unit or a
 subprogram.  A control statement can be conditional (such as the IF
 or computed GO TO statement) or unconditional (such as the STOP or
 GO TO statement).

 critical region

 A section of code (such as parallel DO-loops) that must execute
 serially (sequentially) to achieve correct results.

 data item

 A unit of data (or value) to be processed.  Includes constants,
 variables, arrays, character substrings, or records.

 data type

 The properties and internal representation that characterize data
 and functions.  The basic data types are integer, real, complex,
 logical, and character.

 data type declaration

 See type_declaration_statement.

 data type length specifier

 The form *n appended to a data type name.  For example, the *4 in
 REAL*4.

 denormalized number

 A computational floating-point result smaller than the lowest value
 in the normal range of a data type (the smallest representable
 normalized number) that gradually underflows and loses precision
 until it reaches the smallest representable subnormal value (.GT.
 or .EQ.  0) for that data type.  You cannot write a constant for a
 denormalized number.

 A range of values for one subscript or index of an array.  An array
 can have from 1 to 7 dimensions.

 dimension bounds

 For a named array, the limits within which the values of the
 subscripts of its array elements must lie.  These bounds are
 specified in an array declaration.  See also array_declaration.

 direct access

 A method for retrieving or storing data in which the data (record)
 is identified by the record number, or the position of the record
 in the file.  The record is accessed directly (nonsequentially);
 therefore, all information is equally accessible.  Also called
 random access.  Contrast with sequential_access.

 double-precision constant

 A processor approximation to the value of a real number that
 occupies 8 bytes of memory and can assume a positive, negative, or
 zero value.  The precision is greater than a constant of real
 (single-precision) type.  On VAX and VMS on AXP processors, the
 range for D_floating is approximately 0.29D-38 to 1.7D38; for
 G_floating, approximately 0.56D-308 to 0.9D308.  On RISC and Alpha
 AXP processors, the range for T_floating is approximately
 2.225D-308 to 1.798D308.  See also denormalized_number.

 driver program (U*X)

 A U*X program that is the user interface to the language compiler.
 It accepts command options and file names and causes one or more
 language utilities or system programs to process each file.

 dummy aliasing

 The sharing of memory locations between dummy (formal) arguments
 and other dummy arguments or COMMON variables that are assigned.

 dummy argument

 A variable name used in a function or subroutine which accepts the
 calling program unit's actual argument value.  Dummy arguments are
 defined in FUNCTION statements, SUBROUTINE statements, and
 statement function definitions.

 edit descriptor

 A nonrepeatable format descriptor that directly displays text or
 affects the conversions performed by subsequent field descriptors.

 See array_element.

 The condition that exists when all records in a file open for
 sequential access have been read.

 error number

 A small integer value denoting an I/O error condition, obtained by
 using the IOSTAT= keyword in an I/O statement.

 executable statement

 A Fortran statement that specifies an action to be performed.

 A scalar field reference, a function reference, or a combination of
 these, joined by operators so that the expression can be reduced to
 a single value.  An expression can have any of the Fortran data
 types.

 See language_extension.

 external file

 A sequence of records that exists in a medium external to the
 executing program.

 external routine

 A procedure or function called from outside the program in which
 the program is defined.  Also called an external subprogram.

 (1) A set of contiguous characters, considered as a single item, in
 a record or line.  (2) A substructure of a STRUCTURE declaration.

 field descriptor

 A repeatable format descriptor that causes the transfer or
 conversion of data to or from its internal representation.

 field separator

 The comma (,) or slash (/) that separates edit descriptors or field
 descriptors in a format specification.

 field width

 The size in characters of the field.  See also field, definition 1.

 A collection of logically related records.  If the file is in
 internal storage, it is an internal file; if the file is on an
 input/output device, it is an external file.

 file access

 The way records are accessed (and stored) in a file.  The Fortran
 file access modes are sequential and direct.  On VMS systems on VAX
 processors, you can also specify the keyed mode of access.

 file organization

 The way records in a file are physically arranged on a storage
 device.  Fortran files can have sequential or relative
 organization.  ON VMS systems on VAX processors, files can also
 have indexed organization.

 fixed-length record type

 A file format in which all the records are the same length.

 Pertaining to a type of computation with real numbers in which the
 decimal point separating whole numbers and fractions is located in
 a single, unchanging (fixed) position.  For example, 99.9 is a
 fixed-point real number.  Contrast with floating-point.

 Pertaining to a type of computation (or data type) with real or
 complex numbers expressed in scientific notation.  In this
 notation, a number is expressed as a factor multiplied by an
 appropriate power of 10.  The decimal point "floats" to store the
 maximum number of significant digits.  For example, 864.5 can be
 expressed as 0.8645 * 10**3 (or 0.8645E3).  Contrast with
 fixed-point.  See also denormalized_number.

 foreground process (U*X)

 A process for which the command interpreter is waiting.  Its
 process group is the same as that of its controlling terminal, so
 the process is allowed to read from or write to the terminal.
 Contrast with background_process.

 foreign file (RISC, AXP)

 An unformatted file which contains data from a foreign platform,
 such as data from a CRAY, IBM, or big endian IEEE machine.

 A specific arrangement of data.  A FORMAT statement specifies how
 data is to be read or written.

 formatted data

 Data written to a file by using formatted I/O statements.  Such
 data contains ASCII representations of binary number values.

 formatted I/O statement

 A statement that contains explicit format specifiers to control the
 translation of data from internal (binary) form within a program to
 external (readable character) form in the records, or vice versa.

 format specification

 The part of a FORMAT statement that specifies data arrangement.  It
 is a list within parentheses that can include field descriptors,
 edit descriptors, and field separators.

 full pathname (U*X)

 See absolute_pathname.

 See function_subprogram.

 function reference

 A reference, in an expression, consisting of a function name and
 its arguments.  A function reference returns a value that is used
 in evaluating the expression in which the function appears.

 function subprogram

 A series of statements that perform some operation and return a
 single value (through the function name) to the calling program
 unit.  A function subprogram begins with a FUNCTION (or optional
 OPTIONS) statement and is invoked by a function reference in a main
 program unit or a subprogram unit.  See also subroutine_subprogram
 and statement_function.

 global optimization

 A level of optimization enabling code motion, strength reduction,
 split life analysis, instruction scheduling, and inlining of
 arithmetic functions.  Global optimization can be thought of as
 optimization within a program unit, that is, across statements.

 "Additional global optimization" is a level of optimization that
 improves speed at the cost of increasing the size of the VMS object
 module or U*X object file.  This optimization includes
 interprocedural analysis, inlining procedures, multiplication and
 division expansion, loop unrolling, and code replication.
 Additional global optimization can be thought of as optimization
 across program units.  See also optimization.

 global section

 A data structure (for example, global COMMON) or shareable image
 section potentially available to all processes in the system.

 global symbol

 A symbol name defined in a VMS module (such as a source, object, or
 image module) or U*X object file, that is available for reference
 by another module or object file.

 hexadecimal constant

 A constant that is a string of hexadecimal digits (range 0 to 9, or
 an uppercase or lowercase letter in the range A to F) enclosed by
 apostrophes and followed by the letter X.  In DEC Fortran, the
 letter X can alternatively precede the string, and the letter Z can
 alternatively precede or follow the string.

 Hollerith constant

 A constant that is a string of printable ASCII characters preceded
 by nH, where n is the number of characters in the string (including
 spaces and tabs).

 implicit typing

 The specification of the type of data to be stored in a variable by
 the beginning letter of the symbolic (variable) name.

 (1) The variable used as a loop counter in a DO statement.  (2) An
 intrinsic function specifying the starting position of a substring
 inside a string.  (3) In VMS, an internal data structure that
 provides a guide, based on key values, to file components in an
 indexed file.

 indexed file organization (VMS)

 A file organization that allows random retrieval of records by key
 value and sequential retrieval of records within the key of
 reference.  Each file contains records and a primary key index
 (and, optionally, one or more alternate key indexes).

 The assignment of an initial value to a variable.

 input/output (I/O)

 The data that a program reads or writes.  Also, devices to read and
 write data.

 integer constant

 A constant that is a whole number with no decimal point.  It can
 have a leading sign and is interpreted as a decimal number.

 interactive process

 A process that must periodically get user input to do its work.
 Contrast with batch process (VMS) or background process (U*X).

 internal file

 The designated internal storage space (or variable buffer) that is
 manipulated during input and output.  An internal file can be a
 character variable, character array, character array element, or
 character substring.  In general, an internal file contains one
 record.  However, an internal file that is a character array has
 one record for each array element.

 intrinsic function

 A subprogram supplied as part of the Fortran library that performs
 mathematical, numeric, character, bit manipulation, and other
 miscellaneous functions.  Also called a built-in or library
 function.  See also 3f_library_routines (which are available on U*X
 systems on RISC).

 To call upon; used especially with reference to subprograms.  For
 example, to invoke a function is to execute the function.

 See input/output.

 iteration count

 The number of executions of the DO range, which is determined as
 follows:

 [(terminal value - initial value + increment value) / increment value]

 key (VMS)

 A value in a file of indexed organization that VMS uses to build
 indexes into the file.  Each key is identified by its location
 within the component, its length, and its data type.  Also called
 the key field.  See also alternate_key, index, and primary_key.

 key of reference (VMS)

 A key used by VMS systems to determine the index to use when
 sequentially accessing components of an indexed file.  See also
 key, indexed_file_organization, and sequential_access.

 keyed access (VMS)

 A method for retrieving or writing data in which the data (a
 record) is identified by specifying the information in a key field
 of the record.  See also key.

 See statement_label.

 language extension

 A DEC Fortran language element that is not part of the FORTRAN-77
 standard.

 library function

 See intrinsic_function.

 A system program that creates an executable program from one or
 more VMS object modules or U*X object files produced by a language
 compiler or assembler.  The linker resolves external references,
 acquires referenced library routines, and performs other processing
 required to create VMS executable images or U*X executable files.

 list-directed I/O statement

 An I/O statement that uses a data list (as do namelist I/O
 statements) instead of using explicit format specifiers.  Input is
 accomplished by READ *, list; output by WRITE *, list.  Contrast
 with formatted_I/O_statement.

 A printed copy of a program.

 local optimization

 A level of optimization enabling optimizations within the source
 program unit and recognition of common expressions.  See also
 optimization.

 local symbol

 A name defined in a program unit that is not accessible outside of
 that program unit.

 logical constant

 A constant that specifies the value .TRUE. or .FALSE..

 logical expression

 An integer or logical constant, variable, function value, or
 another constant expression, joined by a relational or logical
 operator.  The logical expression is evaluated to a value of either
 true or false.  For example, .NOT.  6.5 + (B .GT.  D).

 logical operator

 A symbol that represents an operation on logical expressions.  The
 logical operators are:  .AND., .OR., .NEQV., .XOR., .EQV., and
 .NOT..

 logical unit

 A channel in memory through which data transfer occurs between the
 program and the device or file.  See also unit_identifier.

 Four contiguous bytes (32 bits) starting on any addressable byte
 boundary.  Bits are numbered 0 to 31.  The address of the longword
 is the address of the byte containing bit 0.  When the longword is
 interpreted as a signed integer, bit 31 is the sign bit.  The value
 of signed integers is in the range -2**31 to 2**31-1.  The value of
 unsigned integers is in the range 0 to 2**32-1.

 A group of statements that are executed repeatedly until an ending
 condition is reached.

 main program

 A program unit containing a PROGRAM statement (or not containing a
 SUBROUTINE, FUNCTION, or BLOCK DATA statement).  The main program
 is the first program unit to receive control when a program is run,
 and exercises control over subprograms.  Contrast with subprogram.

 makefile (U*X)

 An argument to the make command containing a sequence of entries
 that specify dependences.  The contents of a makefile override the
 system built-in rules for maintaining, updating, and regenerating
 groups of programs.  For more information, see make(1).

 message file

 A file (or catalog, in U*X) that contains the diagnostic message
 text of errors that may occur during program execution (run time).

 misaligned data

 Data not aligned on a natural boundary.  See also natural_boundary.

 A portion of a program or program library, as in a source module,
 object module, or image module; a program unit that contains or
 causes definitions that other program units can access.

 multinational character set

 An 8-bit character encoding scheme associating an integer from 128
 through 255 with 128 characters.  This character set contains
 international alphanumeric characters, including characters with
 diacritical marks.  See also ASCII.

 named common block

 A common block (one or more contiguous areas of storage) with a
 name.  Common blocks are defined by a COMMON statement.

 namelist I/O statement

 An I/O statement that uses a data list (as do list- directed I/O
 statements) instead of using explicit format specifiers.  Input is
 accomplished by READ namelist; output by WRITE namelist.  Contrast
 with formatted I/O statement.

 natural boundary

 The virtual address of a data item that is the multiple of the size
 of its data type.  For example, a REAL*8 data item aligned on
 natural boundaries has an address that is a multiple of eight.

 naturally aligned record

 A record that is aligned on a natural boundary up to 8 bytes; each
 field is naturally aligned.  Contrast with packed_record.

 The placing of one structure inside another structure of the same
 kind.  For example, nesting a loop within another loop (a nested
 loop), or nesting a subroutine within another subroutine (a nested
 subroutine).

 nonexecutable statement

 A Fortran statement that describes program attributes, but does not
 cause any action to be taken when the program is executed.

 numeric storage unit

 The amount of storage needed to represent one REAL, INTEGER, or
 LOGICAL value.  In DEC Fortran, one numeric storage unit is
 equivalent to 4 bytes of memory.

 object file (U*X)

 The binary output of an U*X language processor (such as an
 assembler or compiler), which can either be executed or be used as
 input to the linker.  Contrast with object_module.

 object module (VMS)

 The binary output of a language processor such as the assembler or
 a compiler, which is used as input to the linker.  Contrast with
 object_file.

 octal constant

 A constant that is a string of octal digits (range of 0 to 7)
 enclosed by apostrophes and followed by the letter O.  In DEC
 Fortran, the string can alternatively be preceded by the letter O.

 The passive element in an expression on which an operation is
 performed.  Every expression must have at least one operand.  For
 example, in I .NE.  J, I and J are operands.  Contrast with
 operator.

 The active element in an expression that performs an operation.  An
 expression can have zero or more operators.  For example, in      
 I .NE.  J, .NE.  is the operator.  Contrast with operand.

 The process of producing efficient object or executing code that
 takes advantage of the hardware architecture to produce more
 efficient execution.  See also global_optimization.

 order of subscript progression

 A characteristic of a multidimensional array in which the leftmost
 subscripts vary most rapidly.

 An error condition occurring when the result of an arithmetic
 operation yields a result that is larger than the maximum value in
 the range of a data type.

 packed record

 A record that starts on an arbitrary byte boundary; each field
 starts in the next unused byte.  Contrast with
 naturally_aligned_record.

 The filling of unused positions in a field or character string with
 dummy data (such as zeros or blanks).

 (1) In general, any quantity of interest in a given situation;
 often used in place of the term "argument." (2) A Fortran named
 constant.

 passed-length character argument

 A dummy argument that assumes the length attribute of the
 corresponding actual argument.  An asterisk (*) specifies the
 length of the dummy character argument.

 The path from the root directory to a subdirectory or file.  See
 also root.

 pipe (U*X)

 A connection that allows one program to get its input directly from
 the output of another program.

 A combination of operating system and hardware that provides a
 distinct environment in which to use a software product.  The DEC
 Fortran platforms are ULTRIX on RISC, DEC OSF/1 on RISC, DEC OSF/1
 on AXP, VMS on VAX, and VMS on AXP.

 The number of significant digits in a real number.  See also
 double-precision_constant and single-precision_constant.

 primary key (VMS)

 The required key within the data records of an indexed file, which
 is used to determine the placement of records within the file and
 to build the primary index.

 A computation that can be invoked during program execution.  It can
 be a subroutine or function, an internal, external, or dummy
 procedure, or a statement function.  A subprogram can define more
 than one procedure if it contains an ENTRY statement.  See also
 subprogram.

 A set of instructions that can be compiled and executed by itself.
 Program blocks contain a declaration and an executable section.

 program section

 A particular common block or local data area for a particular
 routine containing equivalence groups; used in data-flow analysis.

 program unit

 A main program or a subprogram; the fundamental component of an
 executable program.  A sequence of statements and optional comments
 that can be a main program, a procedure, an external program, or a
 block data program unit.

 Four contiguous words (64 bits) starting on any address- able byte
 boundary.  Bits are numbered 0 to 63.  (Bit 63 is used as the sign
 bit.) A quadword is identified by the address of the word
 containing the low-order bit (bit 0).  The value of the quadword is
 in the range -2**63 to 2**63-1.

 random access

 See direct_access.

 real constant

 A constant that is a number written with a decimal point, exponent,
 or both.  It can have single precision (REAL*4) or double precision
 (REAL*8); on VAX processors, it can also have quad precision
 (REAL*16).

 (1) A set of logically related data items (in a file) that is
 treated as a unit; such a record contains one or more fields.  This
 definition applies to I/O records and items that are declared
 RECORD.  (2) One or more data items that are grouped in a structure
 declaration and specified in a RECORD statement.  See also field
 and structure_declaration.

 record access

 The method used to store and retrieve records in a file.

 record type

 The property that determines whether records in a file are all the
 same length, of varying length, or use other conventions to define
 where one record ends and another begins.

 recursion

 The act of a routine directly or indirectly calling itself.

 relational expression

 An expression containing one relational operator and two operands
 of numeric or character type.  The result is a value that is true
 or false.  For example, A-C .GE.  B+2, or DAY .EQ.  'MONDAY'.

 relational operator

 The symbols used to express a relational condition or expression:
 .EQ., .NE., .LT., .LE., .GT., and .GE..

 relative pathname (U*X)

 A directory path expressed in relation to any directory other than
 the root directory.  Contrast with absolute_pathname.

 relative file organization (VMS, U*X on RISC)

 A file organization that consists of a series of component
 positions, called cells, numbered consecutively from 1 to n.  DEC
 Fortran use these numbered, fixed-length cells to calculate the
 component's physical position in the file.

 An acronym for Reduced Instruction Set Computing; a type of
 computer architecture design for which the goal of high performance
 is attained through having the processor implement only a minimal
 set of instructions.  Though AXP is also a RISC architecture, in
 this Help file, RISC is used as a label for the DECstation and
 DECsystem platforms.

 root (U*X)

 The top-level directory in the U*X file system.  The root directory
 is represented by a slash (/).

 A subprogram; a function or procedure.  See also
 function_subprogram, subroutine_subprogram, and procedure.

 run time

 The time during which a computer executes the statements of a
 program.

 Pertaining to single data items.  Contrast with vector.

 scalar memory reference

 A reference to a scalar variable, scalar record field, or array
 element that resolves into a single, typed data item and can be
 assigned a value with an assignment statement.  It is similar to a
 scalar reference, but it excludes constants, character substrings,
 and expressions.

 scalar reference

 A reference to a scalar variable, scalar record field, array
 element, constant, character substring, or expression that resolves
 into a single, typed data item.  Contrast with
 scalar_memory_reference.

 scalar variable

 A variable name specifying one storage location.  Contrast with
 array_name.

 scale factor

 A number indicating the location of the decimal point in a real
 number and, if there is no exponent, the size of the number on
 input.

 The portion of a program in which a declaration or a particular
 name has meaning.

 A value (which can be assigned to a variable) that is required in
 order to properly determine the result of the calculation; for
 example, the argument i in the random number generator (RAN)
 function syntax:  y = RAN (i).

 sequential access

 A method for retrieving or storing data in which the data (record)
 is read from, written to, or removed from a file based on the
 logical order (sequence) of the record in the file.  (The record
 cannot be accessed directly.) Contrast with direct_access.

 sequential file organization

 A file organization in which records are stored one after the
 other, in the order in which they were written to the file.

 short field termination

 The use of a comma (,) to terminate the field of a numeric field
 descriptor.  This technique overrides the field width (w)
 specification in the field descriptor and therefore avoids padding
 of the input field.  The comma can only terminate fields less than
 w characters long.  See also field_descriptor.

 The software mechanism used to indicate that an exception condition
 (abnormal event) has been detected.  For example, a signal can be
 generated by a program or hardware error, or by request of another
 program.

 single-precision constant

 A processor approximation of the value of a real number that
 occupies 4 bytes of memory and can assume a positive, negative, or
 zero value.  The precision is less than a constant of
 double-precision type.  On VAX and VMS on AXP processors, the range
 for F_floating is approximately 0.29E-38 to 1.7E38.  On RISC and
 AXP processors, the range for S_floating is approximately 1.175E-38
 to 3.403E38.  See also denormalized_number.

 source program

 A program (or code) in a high-level language form.  Also called
 source code.

 specification statement

 A nonexecutable statement that provides information about the data
 used in the source program.  Such a statement can be used to
 allocate and initialize variables, arrays, records, and structures,
 and define other characteristics of symbolic names used in a
 program.

 An instruction in a programming language that represents a step in
 a sequence of actions or a set of declarations.  There are two main
 classes of statements:  executable and nonexecutable.  See also
 executable_statement and nonexecutable_statement.

 statement block

 A sequence of zero or more statements following a block IF
 statement up to, but not including, the next block IF statement.
 Block IF statements can begin with IF THEN, ELSE IF THEN, or ELSE,
 and end with END IF.

 statement function

 A computing procedure defined in a single Fortran statement.  A
 statement function is invoked by a function reference in a main
 program unit or a subprogram unit; it must precede all executable
 statements and follow all specification statements.

 statement function definition

 A statement that defines a statement function.  Its form is the
 statement function name (followed by its optional dummy arguments
 in parentheses), followed by an equal sign (=), followed by a
 numeric, logical, or character expression.  See also
 statement_function.

 statement label

 An integer, from 1 to 5 digits long, that is used to identify a
 statement.  For example, statement labels can be used to refer to a
 FORMAT statement, or transfer control.

 static variable

 A variable whose storage is allocated for the entire execution of a
 program.

 storage location

 An addressable unit of main memory.

 storage unit

 The amount of storage used to represent one REAL, INTEGER, LOGICAL,
 or character value.  See also numeric_storage_unit and
 character_storage_unit.

 structure declaration

 A block of statements that define the fields in a record.  The
 block begins with a STRUCTURE statement and ends with END
 STRUCTURE.  The name of the structure must be specified in a RECORD
 statement.

 An external function or subroutine that can be invoked from another
 program unit to perform a specific task.  Contrast with
 main_program.

 See subroutine_subprogram.

 subroutine subprogram

 A procedure that can return many values, a single value, or no
 value to the calling program unit (through arguments).  A
 subroutine subprogram begins with a SUBROUTINE (or optional
 OPTIONS) statement and is invoked by a CALL statement in another
 program unit.  See also function_subprogram and statement_function.

 An integer value, enclosed in parentheses and used with an array
 name, that specifies the position of an array element.  See also
 array, array_name, array_element.

 subscript expressions

 A list of expressions, enclosed in parentheses, that determine
 which element in the array is being referenced.  The subscript is
 appended to the array name to which it refers.

 symbolic name

 A unique name used to identify an entity within a Fortran program
 unit.  A symbolic name identifies one entity in a program unit
 (such as a function or subroutine), or it can identify a common
 block, record, structure, structure field, array, or variable.

 The formal structure of a statement or command string.

 transfer list

 The list of statement labels in a computed GO TO statement; the
 labels are separated by commas.

 (1) A technique that approximates a numeric value by dropping its
 fractional value and using only the integer portion.  (2) The
 process of removing one or more characters from the left or right
 of a number or string.

 type declaration statement

 A nonexecutable statement specifying the data type of one or more
 variables:  an INTEGER, REAL, DOUBLE PRECISION, COMPLEX, DOUBLE
 COMPLEX, CHARACTER, LOGICAL, or TYPE statement.  Also called a type
 declaration or type specification.

 unary operator

 An operator that operates on one operand.  For example, the minus
 sign in -A and the .NOT.  operator in .NOT.  (J .GT.  K).

 An error condition occurring when the result of an arithmetic
 operation yields a result that is smaller than the minimum value in
 the range of a data type.  For example, in unsigned arithmetic,
 underflow occurs when a result is negative.  See also
 denormalized_number.

 unformatted data

 Data written to a file by using unformatted I/O statements; for
 example, binary numbers.

 unformatted I/O statements

 A statement that does not contain format specifiers and therefore
 does not translate the data being transferred.

 unformatted record

 A record that is transmitted in internal format between internal
 and external storage.

 unit identifier

 The number that specifies an external unit or internal file.  The
 number can be any one of the following:  an integer expression
 whose value must be zero or positive; an asterisk (*) that
 corresponds to the default input or output unit; the name of a
 character scalar memory reference or character array name reference
 for an internal file.  Also called a device code, or logical unit
 number.

 A value stored in a memory location that may change during the
 execution of a program.  A variable is a value that is referenced
 by a symbolic name (identifier).  See also symbolic_name.

 variable-length record type

 A file format in which records may be of different lengths.

 A data structure comprising scalar elements with the same data type
 and organized as a simple linear sequence.  Contrast with scalar.