CONTROL DATA® 6600 Computer System
Programming System/ Reference Manual
n
^viSSCiSstftir*
1 PIT
SECOND EDITION!
•
m
i
€)
PREFACE
The FORTRAN*-66 language contains most of the features of FORTRAN-63. The FORTRAN-66 compiler
adapts current techniques to the particular capabilities of the Control Data® 6600 Computer System. Emphasis
has been placed on producing highly efficient object programs while maintaining the efficiency of compilation.
This reference manual was written as a text for advanced FORTRAN-66 classes and as a reference manual for
programmers using the FORTRAN-66 system. The manual assumes a basic knowledge of the FORTRAN
language.
•
* FORTRAN is an abbreviation for FORmula TRANslation and was originally developed for International Business Machine
equipment.
^^.
•
TABLE OF CONTENTS
1. ELEMENTS OF FORTRAN 66
1.1 CONSTANTS 1-1
1.2 VARIABLES 1-2
1.3 STATEMENTS 1-4
1.4 EXPRESSIONS 1-4
2. ARITHMETIC EXPRESSIONS AND REPLACEMENT
STATEMENTS
2.1 ARITHMETIC REPLACEMENT STATEMENTS 2-1
2.2 ARITHMETIC EXPRESSIONS 2-1
2.3 MIXED MODE ARITHMETIC EXPRESSIONS 2-2
2.4 MIXED MODE REPLACEMENT STATEMENT 2-3
3. LOGICAL/RELATIONAL AND MASKING EXPRESSIONS
AND REPLACEMENT STATEMENTS
3.1 LOGICAL EXPRESSION 3-1
3.2 RELATIONAL EXPRESSION 3-2
3.3 MASKING REPLACEMENT STATEMENT 3-3
3.4 MASKING EXPRESSIONS 3-3
3.5 MULTIPLE REPLACEMENT STATEMENTS 3-4
4. TYPE DECLARATIONS AND STORAGE ALLOCATIONS
4.1 TYPE DECLARATIONS 4-1
4.2 DIMENSION 4-2
4.3 COMMON 4-2
4.4 COMMON BLOCKS 4-2
4.5 EQUIVALENCE 4-3
4.6 DATA 4-4
4.7 BANK 4-5
5. CONTROL STATEMENTS
5.1 STATEMENT IDENTIFIERS 5-1
5.2 GO TO STATEMENTS 5-1
5.3 IF STATEMENTS 5-1
5.4 FAULT CONDITION STATEMENTS 5-2
5.5 DO STATEMENT 5-3
5.6 CONTINUE 5-5
5.7 PAUSE 5-5
5.8 STOP 5-5
5.9 END 5-5
6. FUNCTIONS AND SUBPROGRAMS
6.1 MAIN PROGRAM AND SUBPROGRAMS 6-1
6.2 FUNCTION SUBPROGRAM 6-1
m
6.3 LIBRARY FUNCTIONS 6-2
6.4 EXTERNAL STATEMENTS 6-2
6.5 STATEMENT FUNCTIONS 6-3
6.6 SUBROUTINE SUBPROGRAM 6-4
6.7 CALL 6-4
6.8 PROGRAM ARRANGEMENT 6-6
6.9 RETURN AND END 6-6
6.10 ENTRY 6-6
6.11 VARIABLE DIMENSIONS IN SUBPROGRAMS 6-7
7. FORMAT SPECIFICATIONS
7.1 THE I/O LIST 7-1
7.2 FORMAT STATEMENT 7-2
7.3 FORMAT SPECIFICATIONS 7-2
7.4 CONVERSION SPECIFICATIONS 7-2
7.5 EDITING SPECIFICATIONS 7-8
7.6 nP SCALE FACTOR 7-10
7.7 REPEATED FORMAT SPECIFICATIONS 7-11
7.8 VARIABLE FORMAT 7-11
8. INPUT/OUTPUT STATEMENTS
8.1 WRITE STATEMENTS 8-1
8.2 READ STATEMENTS 8-1
8.3 BUFFER STATEMENTS 8-2
8.4 TAPE HANDLING STATEMENTS 8-2
8.5 STATUS CHECKING STATEMENTS , 8-3
8.6 ENCODE/DECODE STATEMENTS , 8-3
APPENDIX A CODING PROCEDURES A-l
APPENDIX B CHARACTER CODES 6600 COMPUTER B-l
APPENDIX C STATEMENTS OF FORTRAN-66 C-l
APPENDIX D LIBRARY FUNCTIONS D-l
APPENDIX E QUANTITIES AND WORD STRUCTURE E-l
APPENDIX F PROGRAM SEGMENTATION F-l
APPENDIX G FORTRAN ERROR PRINTOUTS G-l
#
H)
IV
€)
6600 COMPUTING SYSTEM
Main frame (center) — contains 10 peripheral and control processors, central processor, central
memory, some I/O synchronizers.
Display console (foreground) — includes a keyboard for manual input and operator control, and two
1 0-inch display tubes for display of problem status and operator directives.
CONTROL DATA 607 tapes (left front)— V2 inch magnetic tape units for supplementary storage;
binary or BCD data handled at 200, 556, or 800 bpi.
CONTROL DATA 626 tapes (left rear)— 1 -inch magnetic tape units for supplementary storage;
binary data handled at 800 bpi.
Disc file (right rear) — Supplementary mass storage device holds 500 million bits of information.
CONTROL DATA 405 card reader (right front)— reads binary or BCD cards at 1200 card per minute rate.
l 9
#
•
SYSTEM ORGANIZATION
The CONTROL DATA® 6600 is a large-scale, solid-
state, general-purpose digital computing system.
The advanced design techniques incorporated in
the system provide for extremely fast solutions to
data processing, scientific and control center prob-
lems.
Within the 6600 are eleven independent computers
(Fig. 1). Ten of these are constructed with the pe-
ripheral and operating system in mind. These ten
have separate memory and can execute programs
independently of each other or the central processor.
The eleventh computer, the central processor, is a
very high-speed arithmetic device. The common
element between these computers is the large
central memory.
4096 WORD
CORE MEMORY
1 '
4096 WORD 1
CORE MEMORY 1
PERIPHERAL
a CONTROL
PROCESSOR
PERIPHERAL
a CONTROL
PROCESSOR
4096 WORD
CORE MEMORY
4096 WORD
CORE MEMORY
PERIPHERAL
a CONTROL
PROCESSOR
i
>
PERIPHERAL
a CONTROL
PROCESSOR
6600 CENTRAL MEMORY
■ >■
(E
O
■ 2
UJ
2
-l
<
K
1-
Z
111
o
o
o
8.
6600
CENTRAL
PROCESSOR
at
8
o
m
z
-I
TO
> '
r
Z
m
2
O
3)
-C
4096 WORD
CORE MEMORY
4096 WORD
CORE MEMORY
PERIPHERAL
a CONTROL
PROCESSOR
PERIPHERAL
a CONTROL
PROCESSOR
6600 CENTRAL MEMORY
4096 WORD
CORE MEMORY
4096 WORD
CORE MEMORY
t
1 i
L
PERIPHERAL
a CONTROL
PROCESSOR
PERIPHERAL
a CONTROL
PROCESSOR
1 4096 WORD
1 CORE MEMORY
4096 WORD ' 1
CORE MEMORY 1
PERIPHERAL
a CONTROL
PROCESSOR
PERIPHERAL
a CONTROL
PROCESSOR
Figure 1 CONTROL DATA 6600
vn
12
INPUT
OUTPUT
CHANNELS
ADD
| MULTIPLY |
UPPER
BOUNDARY
CENTRAL
MEMORY
MULTIPLY
DIVIDE
24
OPERATING
REGISTERS
>] LONG ADD~
LOWER
BOUNDARY
SHIFT
BOOLEAN
INCREMENT
BRANCH
PERIPHERAL & CONTROL PROCESSORS
CENTRAL PROCESSOR
%
CENTRAL MEMORY
- 131,072 words
— 60-bit words
— Memory organized in 32 logically independent
banks of 4096 words with corresponding multi-
phasing of banks
— Random access, coincident-current, magnetic core
— One major cycle for read-write
— Maximum memory reference rate to all banks —
one address/minor cycle
— Maximum rate of data flow to/from memory —
one word/minor cycle
DISPLAY CONSOLE
— Two display tubes
— Modes
Character
Dot
— Character size
Large — 16 characters /line
Medium — 32 characters/line
Small — 64 characters/line
— Characters
26 alphabetic
10 numeric
11 special
Figure 2 BLOCK DIAGRAM OF 6600
VI 11
I
1. ELEMENTS OF FORTRAN-66
1.1 CONSTANTS
Four basic types of constants are used in
FORTRAN-66: integer, octal, floating point and
Hollerith. Complex and double precision constants
can be formed from floating point constants. The
type of a constant is determined by its form. The
computer word structure for each type is given in
Appendix E.
1.1.1 INTEGER
Integer constants may consist of up to 18 decimal
digits, in the range from — (2 s " — 1) to (2 S!I — 1).
Integer multiply and divide are executed in floating
point modules. No double precision is performed on
integer values; if multiply and divide a re specified,
operands and result will be taken modular 2 4T .
Examples:
63
-247
314159265
3647631
464646464
1.1.2 OCTAL
Octal constants may consist of up to 20 octal digits.
The form is:
n x — n,B
Examples:
77777777000000000000B
7777700077777B
23232323232323232323B
77B
7777777777777700B
1.1.3 FLOATING POINT
Real constants are represented by a string of up to
15 digits. A real constant may be expressed with a
decimal point or with a fraction and an exponent
representing a power of ten. The forms of real con-
stants are:
nE n.n n. ,n nE±s n.nEzbs n.E±s .nE±s
n is the coefficient; s is the exponent to the base 10.
The plus sign may be omitted for positive s. The
range of s is through 308.
Examples:
3.1415768
314.
.0749162
314159E-05
31.41592E-01
.31415E01
.31415E + 01
Double precision constants are represented by a
string of up to 29 digits. The forms are:
nD±s ,nD±s nD n.nD n.D .nD
n.nD±s n.Dzts
n is the coefficient; s is the exponent to the base 10.
The D must always appear. The plus sign may be
omitted for positive s; the range of s is through
308.
Examples:
3. 1415926535897932384626D
3.1415D
3.1415D0
3141.598D-03
31415.D-04
379867524430111D + 01
Complex constants are represented by pairs of real
constants separated by a comma and enclosed in
parentheses (R T , R 2 ). The real part of a complex
number is represented by R 1( the imaginary part by
R 2 . Either constant may be preceded by a — sign.
Examples:
FORTRAN-66
Representation
(1., 6.55)
(15., 16.7)
(-14.09, 1.654E-04)
(0., -1.)
Complex Number
l. + 6.55i
15. + 16.7i
- 14.09 +.0001654i
1.1.4 HOLLERITH
A Hollerith constant is a string of alphanumeric
1-1
characters of the form hHf; h is an unsigned deci-
mal integer representing the length of the field f and
must be 10 or less characters except when used in a
format statement. Spaces are significant in the field f .
When h is not a multiple of 10, the last computer
word is left-justified with BCD spaces filling the
remainder of the word.
An alternate form of a Hollerith constant is hRf.
When h is less than or equal to 10, the computer
word is right-justified with zero fill. When h is
greater than 10 only the first 10 characters are
retained and the excess characters are discarded.
Examples:
6HCOGITO
4HERGO
3HSUM
8RCDC 6600
8R **
1R)
1.2 VARIABLES
FORTRAN-66 recognizes simple and subscripted
variables. A simple variable represents a single
quantity; a subscripted variable represents a single
quantity within an array of quantities. The variable is
either defined in a TYPE declaration or determined
by the first letter of the variable name. A first letter
of I, J, K, L, M, or N indicates a fixed point (integer)
variable; any other first letter indicates a floating
point variable. However, a TYPE declaration over-
rides any other naming convention. (See Section
4-1.)
1.2.1 SIMPLE
A simple variable is the name of a storage area in
which values can be stored. The variable is refer-
enced by the location name; the value specified by
the name is always the current value stored in that
location.
Simple integer variables are identified by at least
one or up to 8 alphabetic or numeric characters; the
first must be I, J, K, L, M, or N. Any integer value
in the range from -(2 5B -1) to 2 59 -1 may be as-
signed to a simple integer variable.
Examples:
N
NOODGE
K2S04
M58
LOX
M58
Since spaces are ignored in variable names, M58
and M 58 are identical.
Simple -floating point variables are identified by at
least one or up to 8 alphabetic or numeric charac-
ters; the first must be alphabetic and not I, J, K, L,
M, or N. Any value from 10" 308 to 10 308 and zero can
be assigned to a simple floating point variable. A
TYPE declaration overrides any other naming con-
vention.
Examples:
VECTOR
BAGELS
A65302
BATMAN
1.2.2 SUBSCRIPTED VARIABLE ARRAYS
A subscripted variable represents an element of an
array. An array is a block of successive memory
locations which is divided into areas for storage of
variables. Each element of the array is referenced
by the array name plus a subscript. The type of an
array is determined by the array name or TYPE
declaration. Arrays may have one, two, or three
dimensions and the maximum number of elements
is the product of the dimensions. A subscript can
be an integer constant, an integer variable, or any
integer expression. Any other constant, variable, or
expression will be reduced to an integer value. The
array name and its dimensions must be declared at
the beginning of the program in a DIMENSION
statement (section 4.2).
Array structure. Elements of arrays are stored by
columns in ascending order of storage location. In
the array declared as A(3,3,3):
Am
A121
A131
A211
A221
A23I
A311
A321
A3SI
A112
A 12 2
A132
A 212
A 2 22
A232
A3 12
A322
A332
A113
A123
A133
A213
A223
A233
A313
A323
A333
%
1-2
The planes are stored in order, starting with the
first, as follows:
A m -^L A 121 -*L+3 ... A 133 ->L+24
A 211 -^L+1 A 221 ->L+4 . . . A 233 -h>L+25
A 311 -»L+2 A 321 -^L+5 . . . A 333 -^L+26
Program errors may result if subscripts are larger
than the dimensions initially declared for the array.
A single subscript notation may be used for a two
or three dimensional array if it does not exceed the
product of the declared dimensions.
1.2.3 SUBSCRIPT FORMS
Subscripted integer variables, the elements of an
integer array, may be assigned the same values as
simple integer values. An integer array is named
by an integer variable name (1 to 8 alphabetic or
numeric characters, the first of which is I, J, K, L,
M, or N), or is designated integer by a TYPE
INTEGER statement.
NEURON (6, 8, 6)
MORPH (20,20)
L6034 (J, 3)
N3 (1)
^^
Subscripted floating point variables, the elements
of a floating point array, may be assigned the same
values as simple floating point variables. A floating
point variable array is named with a floating point
variable name (1 to 8 alphabetic or numeric charac-
ters, the first of which is alphabetic and not I, J, K,
L, M, or N), or is designated floating point by a
TYPE REAL statement.
TMESIS (6, 4, 7) YCLEPT (46)
PST (6, 8) SVELTE (37, 24, 35)
Any computable arithmetic expression may be used
as a subscript.
A (I, J) A(MAXF(I, J, M) )
B (I + 2,J + 3,2*K+1) B(J, ATANF(J) )
Q (14) C(I+K)
P(KLIM, JLIM + 5)
MOTZO (3*K*ILIM + 3.5)
SAM (J -6) WOW(I(J(K) ) )
The location of an array element with respect to
the first element is a function of the maximum array
dimensions and the type of the array. Given DI-
MENSION A(L, M, N) the location of A (i, j, k),
with respect to the first element A of the array, is
given by
A+{i-l+L(j-l+M(k-l))}*E
The quantity in braces is the subscript expression.
If it is not an integer value, it is truncated after
evaluation.
E is the element length, that is, the number of stor-
age words required for each element of the array;
for real and integer arrays, E = 1. (See Appendix E)
1. Referring to the matrix in 1.2.2, the location of
A (2,2,3) with respect to A (1,1,1) is:
Locn (A(2,2,3)} = Locn {A(l,l,l) }
+ {2-1+3(1 + 3(2))}
= L+22
2. Given DIMENSION Z (5,5,5) and 1 = 1, K= 2,
X=45°, A=7.29, B = 1.62. The location, z, of Z
(I*K, TANF(X), A-B) with resrject to Z U.1,1) is:
z = Locn (Z(l,l,l)) + (2-1 + 5
([TANF(X)] -l + 5[4.67]))
= Locn (Z(l,l,l)) + (2-1 + 5
(1-1 + 5*4))
= Locn (Z(l,l,l))+ 101
FORTRAN-66 permits the following relaxation of
the representation of subscripted variables:
Given A(D 1; D 2 ,D 3 ):
where the Di are integer constants,
then A(I,J,K) implies A(IJ,K)
A(IJ) implies A(I,J,1)
A(I) implies A(I,1,1)
A implies A(l,l,l)
similarly, for A(D 1: D 2 )
A(I,J) implies A(I,J)
A(I) implies A(I,1)
A implies A(l,l)
and for A(D a )
A implies A(l)
However, the elements of a single-dimension array
1-3
A(DO may not be referred to as A(IJ,K) or A(IJ).
Array allocation is discussed under Storage Alloca-
tion in Section 4.
1.3 STATEMENTS
The FORTRAN-66 elements are combined to form
statements. An executable statement performs a cal-
culation or directs control of the program; a non-
executable statement provides the compiler with
information regarding variable structure, array allo-
cation, storage sharing requirements.
1.4 EXPRESSIONS
An expression is a constant, variable (simple or sub-
scripted), function (section 7.2) or any combination
of these separated by operators and parentheses,
written to comply with the rules given for con-
structing a particular type of expression.
There are four kinds of expressions in FORTRAN-
66: arithmetic and masking (Roolean) expressions
which have numerical values, and logical and rela-
tional expressions which have truth values. For
each type of expression, there is an associated
group of operators and operands.
•
♦
1-4
fj
2. ARITHMETIC EXPRESSION AND
REPLACEMENT STATEMENTS
2.1 ARITHMETIC REPLACEMENT
STATEMENTS
The general form of the arithmetic replacement
statement (arithmetic statement) is A^E, where E
is an arithmetic expression and A is any variable
name, simple or subscripted. The operator = means
that A is replaced by the value of the evaluated ex-
pression, E, with conversion for mode if necessary.
2.2 ARITHMETIC EXPRESSIONS
An arithmetic expression can contain the following
operators :
OPERATOR MEANING
+ addition
— subtraction
* multiplication
/ division
* * exponentiation
Operands are: Constants
Variables (simple or subscripted)
Functions (see Chapter 7)
Examples:
A
3.141592
B + 16.8946
(A-B(IJ+K) )
G*C(J)+4.1/(Z(I+J,3*K))*SINF(V)
(Q+V(M,MAXF(A,B) )*Y**2)/(G*H-F(K+3) )
-C + D(IJ)*13.627
Any variable (with or without subscripts), constant,
or function is an arithmetic expression. These enti-
ties may be combined by using the arithmetic op-
erators to form algebraic expressions.
Rules:
1. An arithmetic expression may not contain adja-
cent arithmetic operators: X op op Y
2. If X is an expression, then (X), ( (X) ), et cetera,
are expressions.
3. If X, Y are expressions, then the following are
expressions:
X+Y X/Y
X-Y X*Y
4. Expressions of the form X**Y and X**( — Y)
are legitimate, subject to the restrictions in sec-
tion 2.3.
5. The following forms of implied multiplication
are permitted:
constant (...) implies constant* (...)
(...)(...) implies (.. .)*(...)
(...) constant implies ( . . . )* constant
(...) variable implies ( . . . )*variable
2.2.1 ORDER OF EVALUATION
The hierarchy of arithmetic operation is:
** exponentiation class 1
/ division class 2
* multiplication
+ addition class 3
— subtraction
In an expression with no parentheses or within a
pair of parentheses, in which unlike classes of op-
erators appear, evaluation proceeds in the above
order. In those expressions where operators of like
classes appear, evaluation proceeds from left to
right. For example, A**B**C is evaluated as
(A**B)**C.
In parenthetical expressions within parenthetical
expressions, evaluation begins with the innermost
expression. Parenthetical expressions are evaluated
as they are encountered in the left to right scanning
process.
When writing an integer expression, it is important
to remember not only the left to right scanning
process, but also that dividing an integer quantity
by an integer quantity always yields a truncated
2-1
result; thus 11/3 = 3. The expression I*J/K may
yield a different result than the expression J/K*I.
For example, 4*3/2 = 6 but 3/2*4=4.
Examples:
In the following examples, R indicates an inter-
mediate result in evaluation:
A**B/C + D*E*F — G is evaluated:
->Ri
-^R 2
-*R 3
^R 4
^R 5
-» R 6 Evaluation completed
A**B/(C + D)*(E*F-G) is evaluated:
A**B
Rx/C
D*E
R 3 *F
R 4 + R 2
R s -G
A**B
C+D
E*F-G
R1/R2
R 4 *R 3
->Ri
^■R 2
-*R 3
Evaluation completed
If the expression contains a function, the function is
evaluated first.
H(13) + C(IJ + 2)*(COSF(Z))**2 is evaluated:
COSF(Z) ->Rx
Ri ** 2 ^r 2
R 2 *C(IJ+2)-+R 3
R 3 + H(13) ->R 4 Evaluation completed
The following is an example of an expression with
embedded parentheses.
A*(B + ((C/D)-E)) is evaluated:
C/D ^R t
R t -E -^R 2
R,+B -h>R 3
R 3 *A -»R, Evaluation completed
A*(SINF(X) + 1.)-Z/(C*(D-(E + F) ) ) is
evaluated:
SINF(X)
->Ri
Rx + 1
^R 2
E + F
-^R 3
D-R 3
->IU
C*R. t
^R 5
Z/R 5
^Re
A * R 2
^•R T
r 7 -r 5
-»R 8
•
Evaluation completed
2.3 MIXED MODE ARITHMETIC
EXPRESSIONS
FORTRAN-66 permits full mixed mode arithmetic.
Mixed mode arithmetic is accomplished through
the special library subroutines. In the 6600 com-
puter system, these routines include complex arith-
metic. The five standard operand types are com-
plex, double, real, integer, and logical.
Mixed mode arithmetic is completely general; how-
ever, most applications will probably mix operand
types, real and integer, real and double, or real and
complex. The following rules establish the relation-
ship between the mode of an evaluated expression
and the types of the operands it contains.
Rules:
1. The order of dominance of the standard oper-
and types within an expression from highest to
lowest is:
COMPLEX
DOUBLE
REAL
INTEGER
LOGICAL
2. The mode of an evaluated arithmetic expres-
sion is referred to by the name of the dominant
operand type.
3. In expressions of the form A**B, the following
rules apply:
• B may be negative in which case the form is :
A**(-B).
• For the standard types (except logical) the
mode/type relationships are:
•>
2-2
m
•
T
y
p
e
Type B
I
R
D
C
I
I
R
D
C
R
R
R
D
C
D
D
D
D
C
C
C
C
C
C
mode of
A**B
For example, if A is complex and B is real, the mode
of A**B is complex.
2.3.1 EVALUATION
1. Given A, B type real; I, J type integer. The
mode of expression A*B — I + J will be real be-
cause the dominant operand is type real. It is
evaluated:
Convert I to real
Convert J to real
A^^-^Rj real
Rx-I^R;. real
R = + J-^R 3 real
Evaluation completed
2. The use of parentheses may change the eval-
uation. A,B,IJ are defined as above. A*B —
(I — J) is evaluated:
I — J-»Ri integer
Convert Rj to real -> R 2
A*B-»R 3 real
R 3 — R 2 -> R.j real Evaluation completed
3. Given C1,C2 type complex; A1,A2 type real.
The mode of expression A1*(C1/C2) + A2 is
complex because its dominant operand is type
complex. It is evaluated:
C1/C2->R 1 complex
Convert Al to complex
Convert A2 to complex
A1*R X -»R 2 complex
R 2 + A2-> R 3 complex Evaluation completed
4. Consider the expression C1/C2+(A1 — A2)
where the operands are defined as in 3 above.
It is evaluated:
Al-A2^Ri real
Convert R x to complex -» R 2
C1/C2-^R 3 complex
R 3 + R 2 -» Rj complex Evaluation completed
5. Mixed mode arithmetic with all standard types
is illustrated by this example.
Given: C complex
D double
R real
I integer
L logical
and the expression C :|: D + R/I — L
The dominant operand type in this expression is
type complex; therefore, the evaluated expression
is of mode complex. It is evaluated:
Convert D,R,I, and L to complex
R/I—» Rj complex
C * Dh> R 2 complex
Ri — L-> R 3 complex
R, + R 3 -»R 4 complex Evaluation completed
If the same expression is rewritten with parentheses
as C*D + (R/I — L) the evaluation proceeds:
Convert I to real
Convert L to real
R/I-^Ri real
Rj — L— > R 2 real
Convert D to complex
Convert R 2 to complex-* R 3
C * D-» R 4 complex
R.i + R 3 ^R 5 complex Evaluation completed
2.4 MIXED MODE REPLACEMENT
STATEMENT
The mode of an evaluated expression is determined
by the type of the dominant operand. This, how-
ever, does not restrict the types that identifier A
may assume. An expression of complex mode may
replace A even if A is type real. The following chart
shows the A, E relationship for all the standard
modes.
2-3
ARITHMETIC REPLACEMENT STATEMENT A = E
A is an Identifier E is an Arithmetic Expression
0(f) is the Evaluated Arithmetic Expression
<i
\v Mode of
Complex
Double
Real
Integer
of A \.
Store real &
Round 0(f) to
Store 0(f) in real
Convert 0(f) to real &
imaginary parts
real. Store in real
part of A. Store
store in real part of A.
Complex
of 0(f) in real &
part of A. Store
zero in imaginary
Store zero in imaginary
imaginary parts
zero in imaginary
part of A.
part of A.
of A.
part of A.
Discard imaginary
Store 0(f) (most
If 0(f) is ± affix
Convert 0(f) to real.
part of 0(f) & re-
& least significant
±0 as least sig-
Fill out least significant
Double
place it with ±0
parts) in A (most
nificant part.
half with binary zeros
according to real
& least signifi-
Store in A, most
or ones accordingly as
part of 0(f).
cant parts).
& least signifi-
cant parts.
sign of 0(f) is plus or
minus. Store in A, most
and least significant
parts.
Store real part of
Round 0(f) to real
Store 0(f) in A.
Convert 0(f) to real.
Real
0(f) in A. Imagi-
nary part is lost.
& store in A.
Least significant
part of 0(f) is
lost.
Store in A.
Truncate real
Truncate 0(f) to
Truncate 0(f) to
Store 0(f) in A.
part of 0(f) to
INTEGER &
INTEGER.
Integer
INTEGER. Store
in A. Imaginary
part is lost.
store in A.
Store in A.
If real part of
If 0(f)^O ; 1->A.
Same as for
Same as for double at
Logical
0(f)^O, 1-*A.
If real part of
0(f) = 0, 0-»A.
If 0(f) = 0,0-* A.
double at left.
left.
When all of the operands in the expression E are
of type logical, the expression is evaluated as though
all the logical operands were integers.
For example, if L 1; L,, L 3 , L 4 are logical variables,
R is a real variable, and I is an integer variable,
then
I = L 1 *L 2 + L 3 -L. 1
will be evaluated as though the L[ were all integers
(0 or 1) and the resulting value will be stored, as
an integer, in I.
R = L 1 *L 2 + L 3 -L 4
is evaluated as stated above, but the result is con-
verted to a real (a floating point quantity) before
it is stored in R.
t.
2-4
Examples:
Given: d , A t complex
Di , A 2 double
Ri , A 3 real
I, , A 4 integer
Li , A 5 logical
A^c^Ca-c/a
(.905,15.393) =
(4.4,2.1)*(3.0,2.0)-(3.3,6.8)/(l.l,3.4)
The mode of the expression is complex. Therefore,
the result of the expression is a two-word, floating
point quantity. A t is type complex and the result
replaces A a .
A^d 4.4000 +000 = (4.4,2.1)
The mode of the expression is complex. The type
of A a is real; therefore, the real part of C t replaces
A 3 .
A a = C 1 *(0.,-2) 4.2000+000 = (4.4,2.1)*(0.,-2)
The mode of the expression is complex. The type
of A 3 is real.
A^ = R 1 /R 2 *(R 8 -IU)+Ii-(l2*R«)
3=8.4/4.2*(3.1-2.1) + 14-(l*2.3)
The mode of the expression is real. The type of A 4
is integer; the result of the expression evaluation, a
real, will be converted to an integer replacing A 4 .
A 2 =D 1 **2*(D 2 + (D 3 *D 4 )) + (D 2 *D 1 *D 2 )
4.96800000000000000000000 + 001 =
2( )D**2*(3.2D + (4.1D*1.0D)) + (3.2D*2.0D*3.2D)
The mode of the expression is double. The type of
A 2 is double; the result of the expression evalua-
tion, a double precision floating quantity, replaces
A 2 .
A 5 = C 1 *R 1 -R 2 + Ii
1 = (4.4,2.1) *8.4- 4.2 + 14
The mode of the expression is complex. Since A 5 is
type logical, an integer 1 will replace A 5 if the real
part of the evaluated expression is not zero. If the
real part is zero, zero replaces A 5 .
^F
2-5
«
♦>
t
3. LOGICAL/RELATIONAL
AND MASKING EXPRESSIONS
AND REPLACEMENT STATEMENTS
The general form of the logical/relational replace-
ment statement is L = E, where L is a variable of
type logical and E may be a logical, relational, or
arithmetic expression.
3.1 LOGICAL EXPRESSION
A logical expression has the general form
O t op Oo op O a . . .
The terms Oj are logical variables, arithmetic ex-
pressions or relational expressions, and op is the
logical operator .AND. indicating conjunction or
.OR. indicating disjunction.
The logical operator .NOT. indicating negation ap-
pears in the form:
.NOT. O t
The value of a logical expression is either true or
false.
When an arithmetic expression appears as a term
of a logical replacement statement, the value of the
expression is examined. If the value is non-zero, the
term has the value TRUE. If the value is equal to
zero, the term has the value FALSE.
Logical expressions are generally used in logical IF-
statements. (See section 5.3)
Rules:
1. The hierarchy of logical operations is:
First .NOT.
then AND.
then .OR.
2. A logical variable or a relational expression is,
in itself, a logical expression. If Lj, L, are
logical expressions, then
.NOT. L x
U .AND. L,
U .OR. L 2
are logical expressions. If L is a logical expres-
sion, (L), ( (L) ) are logical expressions.
3. If L,, L 2 are logical expressions and op is
AND. or .OR. then, L, op op L 2 is never legiti-
mate.
4. .NOT. may appear in combination with AND.
or .OR. only as follows :
AND. .NOT.
.OR. .NOT.
AND. (.NOT. . . .)
.OR. (.NOT. . . .)
.NOT. may appear with itself only in the form
.NOT. (.NOT.(.NOT. . . .
5. If Li, L 2 are logical expressions, the logical
operators are defined as follows:
.NOT. U
U AND. L 2
U .OR. L 2
is false only if L t is true
is true only if L l5 L 2 are
both true
is false only if L 1; L 2 are
both false
Incorrect usages such as the following are not per-
mitted:
Q.NOT. .OR.R
CAND. .NOT. .NOT.B
The last expression is permissible in the form
CAND. .NOT.(.NOT.B)
Examples:
Logical Expressions
{The product A*B greater than 16.} AND.
{C equals 3.141519}
A*B .GT. 16. AND. C .EQ. 3.141519
3-1
(begin)
AXB-16.-»L t
C Is L t >0? ) -/fALSEJ
{A(I) greater than 0} .OR. {B(J) less than 0}
a(i).gt.o.or.b(j).lt.o
(begin)
(" Is A(i)>0? ^^-(tRUEJ
NO
( IsB(j)<0? )
YES
In the two examples below,
all L, are of TYPE LOGICAL
(L2.0R...NOT.L3)
BEGIN
( IsL ^ 0? y^-* ( IsL=0? )
YES
«•
YES
(true)
L2.0R..N0T.L3
.AND.(.NOT.L6,OR.L5)
(trueY—
(begin)
YES /• " \
i — C IsL ^ 0? )
NO
Is L 3 = 0?
YES
)
NO
YES
FALSE
C Is L 6 = 0? )
YES
NO
(^ Is L 5 ^0? ^
NO
%
♦)
3.2 RELATIONAL EXPRESSION
A relational expression has the form:
qi op q 2
The q's are arithmetic expressions; op is an operator
belonging to the set:
Operator Meaning
.EQ. Equal to
.NE. Not equal to
.GT. Greater than
.GE. Greater than or equal to
XT. Less than
.LE. Less than or equal to
A relation is true if q 1 and q 2 satisfy the relation
specified by op. A relation is false if q x and q, do
not satisfy the relation specified by op.
Relations are evaluated as illustrated in the rela-
tion, p .EQ. q. This is equivalent to the question,
does p — q = 0?
The difference is computed and tested for zero. If
the difference is zero, the relation is true. If the dif-
ference is not zero, the relation is false. Relational
expressions are converted internally to arithmetic
expressions according to the rules of mixed mode
arithmetic. These expressions are evaluated and
compared with zero to determine the truth value of
the corresponding relational expression. When ex-
pressions of mode complex are tested for zero, only
3-2
the real part is used in the comparison.
Rules:
1. The permissible forms of a relation are:
q (where a non-zero value is true
and a zero value is false)
qi op q 2
q t op q, .AND. q, op q 3
2. The evaluation of a relation of the form q 1 op q- 2
is from left to right. The relations q t op q 2 , q t op
(q,), (q t ) op q 2 , (q t ) op (q 2 ) are equivalent.
Examples:
A.GT. 16. R(I) .GE. R(I-l)
R-Q(I)*Z.LE. 3.141592 K XT. 16
B-C.NE. D + E I.EQ.J(K)
3.3 MASKING REPLACEMENT
STATEMENT
The general form of the masking replacement state-
ment is M = E. The masking statement is distin-
quished from the logical statement in the following
ways.
1. The type of M must be real or integer.
2. All operands in the expression E must be type
real or integer. E may contain functions as well as
variable or constant operands.
Examples:
Given: All variables of type real or integer.
A(I) = B .OR. .NOT. C(I)
B = D .AND. Q
C(IJ) = .NOT. Z(K) .AND. (Ql .OR.
.NOT. Q2)
TEST = CELESTE .AND. 7HECLIPSE
AB = D .OR. FUNC (X,T)
*ilP
3.4 MASKING EXPRESSIONS
In a FORTRAN-66 masking expression 60-bit
arithmetic is performed bit-by-bit on the operands
within the expression.
Although the masking operators are identical in
appearance to the logical operators, their meanings
are different. They are listed accordingly to hier-
archy, and the following definitions apply:
.NOT. complement the operand
.AND. form the bit-by-bit logical product
of two operands
.OR. form the bit-by-bit logical sum of
two operands
The operations are described below.
p
V
p .AND. v
p .OR.v
.NOT.p
1
1
1
1
1
1
1
1
1
1
Rules:
1. Let Bi be masking expressions, variables or con-
stants whose types are real or integer. Then the
following are masking expressions.
.NOT. B, B, .AND. B 2 B a .OR. B 2
2. If B is a masking expression, then (B), ((B)) are
masking expressions.
3. .NOT. may appear with AND. or .OR. only as
follows :
.AND. .NOT.
.OR. .NOT.
.AND. (.NOT. . . .)
.OR. (.NOT. . . .)
4. Masking expressions of the following forms are
evaluated from left to right.
2 A. .AND. B .AND. C . . .
A .OR. B. OR. C . . .
5. Masking expressions may contain logical oper-
ands, parenthetical arithmetic expressions and
statement functions.
Examples:
A 1 77770000000000000000 octal constant
A, 00000000000077777777 octal constant
3-3
B 00000000000000001763 octal form of integer
constant
C 20045000000000000000 octal form of real
constant
.NOT. A, is 00007777777777777777
Ai AND. C is 20040000000000000000
A 1 .AND. .NOT. C is 57730000000000000000
B .OR. .NOT. A 2 is 77777777777700001763
3.5 MULTIPLE REPLACEMENT
STATEMENTS
The multiple replacement statement is a general-
ization of the replacement statements discussed
earlier in this and the previous chapter, and its
form is:
fa, = fa^-i — • ■ ■ — fa- = ^i = expression
The expression may be arithmetic, logical or mask-
ing. The fa are variables subject to the following
restrictions :
Arithmetic or Logical Statement: fa = ZAP
If ZAP is logical or arithmetic and:
If the variable fa is type complex, double, real,
or integer, then fa = ZAP is an arithmetic state-
ment.
If the variable fa is type logical, then fa = ZAP
is a logical statement.
Masking Statement: fa = ZAP
If ZAP is a masking expression, fa must be a
type real or integer variable only.
The remaining n — l*i may be variables of any type
and the multiple replacement statement replaces
each of the variables *i ( 2 ^ i ^ n ) in turn with the
value of *i — 1 in a manner analogous to that em-
ployed in mixed mode arithmetic statements.
Examples:
A real
E,F complex
G double
I integer
K logical
The numbers in the examples represent the evalua-
tions of expressions.
A = G = 3.1415926535897932384626D
3.1415926535897932384626D-> G
%
3.141592654
I = A = 4.6
A = I = 4.6
I = A = E = (10.2,3.0)
->A
4.6^ A
4 -*I
4 ^1
4.0-^ A
10.2-> E real
3.0-> E
imaginary
10.2->A
10 -*I
F = A = I = E = (13.4, 16.2) 13.4^ E real
16.2->E
imaginary
13 ^1
13.0-* A
13.0-> F real
0.0 ^F
imaginary
f
K> I = -14.6
I = K= -14.6
14 ->I
1 -*K
1 ^K
1 ^1
V
3-4
4. TYPE DECLARATIONS AND
STORAGE ALLOCATIONS
•
4 ^^f
4.1 TYPE DECLARATIONS
The TYPE declaration provides the compiler with
information on the structure of variable and func-
tion identifiers. There are five standard variable
types which are declared by one of the following
statements :
Statement Characteristics
TYPE COMPLEX List 2 words/element
Floating point
TYPE DOUBLE List 2 words/element
Floating point
TYPE REAL List 1 word/element
Floating point
TYPE INTEGER List 1 word/element
Integer
TYPE LOGICAL List 1 word/element
Logical (non-
dimensioned )
1 bit/ element,
32 bits/word
Logical
( dimensioned )
A list is a string of identifiers separated by commas;
subscripts are not permitted. An example of a list is :
A, Bl, CAT, D36F, EUPHORIA
Rides:
1. The TYPE declaration is non-executable and
must precede the first executable statement in
a given program.
2. An identifier may not be declared in two or
more TYPE declarations.
3. An identifier not declared in a TYPE statement
is an integer if the first letter of the identifier is
I, J, K, L, M, N; for any other letter, it will be
real.
4. If TYPE, DIMENSION or COMMON appear
together, the order is immaterial.
Examples:
TYPE COMPLEX A147, RIGGISH, AT1LL2
TYPE DOUBLE TEEPEE, B2BAZ
TYPE REAL EL, CAMINO, REAL, IDE63
TYPE INTEGER QUID, PRO, QUO
TYPE LOGICAL GEORGE6
4.2 DIMENSION
A subscripted variable represents an element of an
array of variables. Storage may be reserved for
arrays by the non-executable statements DIMEN-
SION or COMMON.
The standard form of the DIMENSION statement
is
DIMENSION Vi, V 2 , . . . , V„
The variable names, Vi, may have 1, 2, or 3 integer
constant subscripts separated by commas, as in
SPACE (5, 5, 5,). Under certain conditions within
subprograms only, the subscripts may be integer
variables. This is explained in section 6.11.
The number of computer words reserved for a
given array is determined by the product of the
subscripts in the subscript string, and the type of
the variable.
In the statements
TYPE COMPLEX HERCULES
DIMENSION HERCULES (10, 20)
the number of elements in the array HERCULES
is 200. Two words are used to store a complex ele-
ment; therefore, the number of computer words
reserved is 400. The argument is the same for double
precision. For reals and integers the number of
words in an array equals the number of elements in
the array.
Rules:
1. The DIMENSION statement is non-executable
and must precede the first executable statement
in a given program.
2. An identifier may not be declared in two or more
DIMENSION statements.
3. If TYPE, DIMENSION or COMMON appear to-
gether, the order is immaterial.
4. For any given dimensional variable, the dimen-
sions may be declared either in a COMMON
statement or in a DIMENSION statement. If de-
clared in both, those of the DIMENSION state-
ment override those declared in the COMMON
statement.
5. Any number of DIMENSION statements may
appear in a program section.
6. A zero subscript is treated as a one.
4-1
4.2.1 VARIABLE DIMENSIONS
When an array identifier and its dimensions appear
as formal parameters in a function or subroutine,
the dimensions may be assigned through the actual
parameter list accompanying the function reference
or subroutine call. The dimensions must not exceed
the maximum array size specified by the DIMEN-
SION statement in the calling program. See section
6.11 for details and examples.
4.3 COMMON
A program may contain or call subprograms. Areas
of common information may be specified by the
statement:
COMMON/L/List/L/List . . .
I is a common block identifier. It may be blank; or
consist of up to 8 characters. If the first character is
a number, then all characters in the identifier must
be numbers. The following are common identifiers:
/AZ13/
/35£
/CAVEAT/
//
/O/
/x/
List is composed of simple variable identifiers and
array identifiers (subscripted or non-subscripted).
If a non-subscripted array name appears in the list,
the dimensions are defined by the DIMENSION
statement in that program.
Dimensions for arrays may also be given in the
COMMON statement when a subscript string ap-
pears with the identifier. If dimensions are given in
both, those in the DIMENSION statement are used.
Examples:
COMMON A, B, C
COMMON/ / A, B, C, D
COMMON/BLOCK1/A, B/1234/C(10),
D(10,10),E(10,10,10)
COMMON/BLOCKA/D(15), F(3,3),
GOSH(2, 3, 4), Ql
If a subprogram does not use all of the locations
reserved in a common block, unused variables may
be necessary in the COMMON statement to insure
proper correspondence of common areas.
|
MAIN PROG
SUB PROG
COMMON/SUM/A, B, C
COMMON/SUM/E, F, G
In the above example, assume only the variables E
and G are used in the subprogram. The unused vari-
able F is necessary to space over the area reserved
by B.
Rules:
1. COMMON is non-executable and must precede
the first executable statement in the program.
Any number of COMMON statements may
appear in a program section.
2. If TYPE, DIMENSION or COMMON appear
together, the order is immaterial.
3. A variable in COMMON may not be equated to
any other variable in COMMON.
4. Common block identifiers are used only for block
identification within the compiler; they may be
used elsewhere in the program as other kinds
of identifiers.
5. An identifier in one common block may not
appear in another common block.
6. For any given dimensional variable, the dimen-
sions may be declared either in a COMMON
statement or in a DIMENSION statement. If de-
clared in both, those of the DIMENSION state-
ment override those declared in the COMMON
statement.
7. At the beginning of program execution, the con-
tents of the common area are undefined unless
specified by a DATA statement.
«■
4.4 COMMON BLOCKS
The COMMON statement provides the program-
mer with a means of reserving blocks of storage
area that are referenced by more than one sub-
program. Data may be stored in common blocks by
the DATA statement and are made available to any
subprogram using the appropriate block.
4-2
4.4.1 BLOCK LENGTH
The length of a common block in computer words
is determined from the number and type of the list
identifiers. In the following statement, the length
of the common block A is 12 computer words. The
origin of the common block is Q(l). Q and R are
real variables and S is complex.
•
COMMON/A/Q(4), R(4), S(2)
b
ock A
origin
Qd)
Q(2)
Q(3)
Q(4)
R(l)
R(2)
R(3)
R(4)
S(l)
real part
S(l)
imaginary part
S(2)
real part
S(2)
imaginary part
Example:
MAIN PROG
COMPLEX C
COMMON/TES17C(20)/36/A,B,Z
The length of TEST is 40 computer words.
The subprogram may rearrange the allocation of
words as in:
SUB PROG 1
COMMON/TEST/A(10),G(10),K(10)
TYPE COMPLEX A
The following arrangements are equivalent:
TYPE DOUBLE A \ ( COMMON A(10)
DIMENSION A(10) | j TYPE DOUBLE A
COMMON A
The label of a COMMON block is used only for
block identification. The following is permissible:
COMMON /A/A(10)/B/B(5,5) /C/C (5,5,5)
4.5 EQUIVALENCE
The EQUIVALENCE statement permits variables
to share locations in storage. The general form is:
EQUIVALENCE (A,B, . . .), (A1,B1, ...),...
(A,B, . . .) is an equivalence group of two or more
simple or singly subscripted variable identifiers. A
multiply subscripted variable can be represented
only by a singly subscripted variable. The corre-
spondence is:
A(i,j,k)=A(i+(j-l)I+(k-l)IJ)
where i,j,k are integer constants: I and J are the
integer constants appearing in DIMENSION A
(IJ.K). For example, in DIMENSION A(2,3,4), the
element A(l,l,2) is represented by A(7).
Examples:
EQUIVALENCE is most commonly used when two
or more arrays can share the same storage locations.
The lengths may be different or equal.
DIMENSION A(10,10), 1(100)
EQUIVALENCE (A,I)
The length of TEST is 40 words. The first 10 ele-
ments (20 words) of the block, represented by A,
are complex elements. Array G is the next 10 words,
and array K is the last 10 words. -Within the sub-
program, elements of G will be treated as floating
point quantities; elements of K will be treated as
integer quantities.
The length of a COMMON block must not be
changed by the subprograms using the block. The
identifiers used within the block may differ as shown
above.
5 READ 10, A
6 READ 20, 1
The EQUIVALENCE statement assigns the first
element of array A and array I to the same storage
location. The READ statement 5 stores the A array
in consecutive locations. Before statement 6 is exe-
4-3
cuted all operations using A must be completed as
the values of array I are read into the storage loca-
tions previously occupied by A.
Rules:
1. EQUIVALENCE is non-executable and must
precede the first executable statement in the
program or subprogram.
2. If TYPE, DIMENSION, COMMON, or EQUIV-
ALENCE appear together, the order is imma-
terial.
3. Any variable or array may be made equivalent to
any other variable or array. The variable or array
may or may not be subscripted in the EQUIV-
ALENCE statement. A given identifier may be
repeated in more than one equivalence group,
but caution must be observed to avoid circular
references. A zero or one subscript is treated as
though the subscript were not present.
4. The EQUIVALENCE statement does not re-
arrange common, but arrays may be defined as
equivalent so that the length of the common
block is changed. The origin of the common block
must not be changed by the EQUIVALENCE
statement. The following simple examples illus-
trate changes in block lengths caused by the
EQUIVALENCE statement.
Given: Arrays A and B
Sa = subscript of A
Sb = subscript of B
Examples:
1. A in COMMON, B not in COMMON
Sb ^ Sa is a permissible subscript
Sb > Sa is not
COMMON/l/A(4)
DIMENSION B(5)
EQUIVALENCE (A(3), B(2))
origin A(l)
A(2) B(l)
A(3) B(2)
A(4) B(3)
B(4)
B(5)
2. B in COMMON, A not in COMMON
Sa ^ Sb is a permissible subscript
4-4
length of block 1
(now 6 elements)
Sa > Sb is not
COMMON/2/B(3)
DIMENSION A(2)
EQUIVALENCE (B(l), A(l))
origin B(l) A(l) \
B(2) A(2) > length of block 2
B(3) J (not increased)
3. A, B not in COMMON
No restrictions on subscript arrangement.
4. A, B both in COMMON
No subscript arrangement is legal.
4.6 DATA
The programmer may assign constant values to
variables in the source program by using the DATA
statement either by itself or with a DIMENSION
statement. It may be used to store constant values
in variables contained in a common block.
DATA(L = List), (I, = List), . . .
I is an identifier representing a simple variable,
array name, or a variable with integer constant sub-
scripts or integer variable subscripts.
List contains constants only and has the form
a 1 ,a 2 , . . . , k(b!,b,, . . . ), c„c u . . .
k is an integer constant repetition factor that causes
the parenthetical list following it to be repeated k
times.
Rules:
1. DATA is non-executable and must precede the
first executable statement in any program or sub-
program in which it appears.
2. When DATA appears with TYPE, DIMENSION,
COMMON or EQUIVALENCE statements, the
order is immaterial.
3. DO loop-implying notation is permissible. This
notation may be used for storing constant values
in arrays.
DIMENSION X( 10,10)
DATA ( ( (X(IJ)I = 1,10,2), J = 6,9,3)
= 2(5(3.1)))
DIMENSION GIB (10)
DATA ( (GIB(I),I = 1,10) = 1. ,2. ,3. ,7(4.32) )
ARRAY GIB
1.
2.
3.
4.32
4.32
4.32
4.32
4.32
4.32
4.32
Examples:
1. DATA (LEDA=15), (CASTOR =16.0),
(POLLUX =84.0)
LEDA
CASTOR
POLLUX
15
16.0
84.0
4. Variables in variable dimensioned arrays may
not be preset in a DATA statement.
5. Either unsigned constants or constants preceded
by a minus sign may be used. Negative octal con-
stants are prefixed with minus signs.
6. There must be a one-to-one correspondence be-
tween the identifiers and the list.
COMMON / TUP / C(3)
DATA (C = l. ,2,3)
2. DATA (A(l,3) = 16.239)
ARRAY A
A(l,3) 16.239
3. DIMENSION B(10)
DATA (B = 77B, - 77B, 4(776B, - 774B) )
ARRAY B 77B
-77B
776B
-774B
776B
-774B
776B
-774B
776B
-774B
4.7 BANK
In FORTRAN-66 the BANK statement acts as a
do-nothing statement. *
4-5
*
•>
%
5. CONTROL STATEMENTS
Program execution normally proceeds from one
statement to the statement immediately following
it in the program. Control statements can be used
to alter this sequence or cause a number of itera-
tions of a program section.
Control may be transferred to an executable state-
ment only; a transfer to a non-executable statement
results in a program error.
Iteration control provided by the DO statement
causes a predetermined sequence of instructions to
be repeated any number of times with the stepping
of a simple integer variable after each iteration.
5.1 STATEMENT IDENTIFIERS
Statements are identified by numbers which can be
referred to from other sections of the program. A
statement number used as a label or tag appears in
columns 1 through 5 on the same line as the state-
ment on the coding form. The statement number N
may lie in the range 1==N^99999. An identifier up
to 5 digits long may occupy any of the first five col-
umns; blanks are squeezed out and leading zeros
are ignored. 1, 01, 001, 0001, are identical, (Appen-
dix A).
5.2 GO TO STATEMENTS
Transfer of control is provided by GO TO state-
ments.
5.2.1 UNCONDITIONAL GO TO
GO TO N
This statement causes an unconditional transfer to
the statement labeled N; N is a statement identifier.
5.2.3 ASSIGN STATEMENTS
ASSIGN N TO m
This statement is used with the assigned GO TO
statement. N is a statement number, m is a simple
integer variable.
ASSIGN 10 TO LSWTCH
GO TO LSWTCH,(5,10,15,20)
Control will transfer to statement 10.
5.2.4 computed GO TO
GO TO (n 1; n 2 , . . . ,n m )i
GO TO (n l5 n 2 . . . ,n m ), i
This statement acts as a many-branch GO TO,
where i is preset or computed prior to its use in
the GO TO.
The rii are statement numbers and i is a simple
integer variable. If i— 1, a transfer to n a occurs; if
i— m, a transfer to n m occurs. Otherwise, transfer
is to nj.
For proper operations, i must not be specified by an
ASSIGN statement.
ISWITCH = 1
GO TO (10,20,30),ISWITCH
"slP
5.2.2 assigned GO TO
GO TO m, (n 1; n 2 . . . ,n m )
This statement acts as a many-branch GO TO. m is
an integer variable assigned an integer value iij in
a preceeding ASSIGN statement. The ni are state-
ment numbers. A parenthetical list need not be
present.
The comma after m is optional when the list is
omitted, m cannot be the result of a computation.
If m is computed, the object code is incorrect.
10 JSWITCH = ISWITCH + 1
GO TO (11,21,31)JSWITCH
Control will transfer to statement 21.
5.3 IF STATEMENTS
Conditional transfer of control is provided by the
one-, two-, and three-branch IF statements, the
status of sense lights or switches.
5-1
5.3.1 THREE BRANCH IF (ARITHMETIC)
IF (A) n^nojii.,
A is an arithmetic expression and the ni are state-
ment numbers. This statement tests the evaluated
quantity A and jumps accordingly.
A < jump to statement iu
A = jump to statement n 2
A > jump to statement n 3
In the test for zero, +0= -0. When the mode of
the evaluated expression is complex, only the real
part is tested for zero.
IF(A*B-C*SINF(X) )10,10,20
IF(I)5,6,7
IF(A/B**2)3,6,6
5.3.2 TWO BRANCH IF (LOGICAL)
IF(L) ni ,n 2
L is a logical expression. The n, are statement
numbers.
The evaluated expression is tested for true (non-
zero) or false (zero). If L is true, jump to statement
rij. If L is false, jump to statement n 2 .
IF(A .GT. 16. .OR. I .EQ.O)5,10
IF(L)1,2 (L is TYPE LOGICAL)
IF(A*B-C)1,2 (A*B-C is arithmetic)
IF(A*B/C .LE. 14.32)4,6
5.3.3 ONE BRANCH IF (LOGICAL)
IF (L)s
L is a logical expression and s is a statement. If
L is true (non-zero), execute statement s. If L is
false (zero), continue in sequence to the statement
following the IF logical.
IF (L) GO TO 3 (L is logical)
IF(L)Y=SINF(X)/2
5.3.4 SENSE LIGHT
SENSE LIGHT i
The statement turns on the sense light i. SENSE
LIGHT turns off all sense lights, i may be a
simple integer variable or constant (1 to 60).
IF(SENSE LIGHT i) n 1: n 2
The statement test sense light i. If it is on, it is
turned off and a jump occurs to statement n t . If it
5-2
is off, a jump occurs to statement n 2 . i is a sense
light and the n, are statement numbers, i may be a
simple integer variable or constant (1 to 60).
IF(SENSE LIGHT 4)10,20
5.3.5 SENSE SWITCH
IF(SENSE SWITCH i) n„n 2
If sense switch i is set (on), a jump occurs to state-
ment rii. If it is not set (off), a jump occurs to state-
ment n 2 ; i may be a simple integer variable or
constant. In the 6600, 1 ^ i ^ 6
N=5
IF(SENSE SWITCH N) 5,10
5.4 FAULT CONDITION STATEMENTS
At execute time, the computer is set to interrupt
on operand out of range. A program may be exe-
cuted with an exit on any fault condition or by
optional exits or tests provided by the program
(SIPROS parameter).
IF DIVIDE CHECK n l5 n 2
IF DIVIDE FAULT n l5 n 2
The above statements are equivalent. A divide
fault occurs following division by zero. The state-
ment checks for this fault; if it has occurred, the
indicator is turned off and a jump to statement n x
takes place. If no fault exists, a jump to statement
n 2 takes place.
IF EXPONENT FAULT n 1; n 2
An exponent fault occurs when the result of a real
or complex arithmetic operation exceeds the upper
limits specified for these types. Results that are less
than the lower limits are set to zero without indica-
tion. This statement is therefore a test for floating-
point overflow only. If the fault occurs, the
indicator is turned off, and a jump to statement n,
takes place. If no fault exists, a jump to statement n 2
takes place.
IF OVERFLOW FAULT n 1; n 2
No overflow condition is provided on 60-bit sums
and differences. A jump to statement n, is gener-
ated for the statement.
i>
\j)
5.5 DO STATEMENTS
DO n i=m 1 ,m 2 ,m3
This statement makes it possible to repeat groups of
statements and to change the value of a fixed point
variable during the repetition, n is the number of
the statement ending the DO loop, i is the index
variable (simple integer). The mi are the indexing
parameters; they may be any computable arithmetic
expression. The initial value assigned to i is im, m 2
is the largest value assigned to i, and m 3 is the
amount added to i after each DO loop is executed.
If m a does not appear, it is assigned the value 1.
The values of m 2 and m 3 may be changed at any
time.
The DO statement, the statement labeled n, and
any intermediate statements constitute a DO loop.
Statement n may not be an IF or GO TO statement
or another DO statement. See Transmission of Ar-
rays section 7.1.1 and DATA Statement section 4.6
for usage of implied DO loops.
5.5.1 DO LOOP EXECUTION
The initial value of i, m 1; is compared with m 2
before executing the DO loop and, if it does not
exceed m 2 , the loop is executed. After this step, i is
increased by m 3 . i is again compared with m 2 ; this
process continues until i exceeds m 2 as shown
below. Control then passes to the statement im-
mediately following n, and the DO loop is satisfied.
If m x exceeds m 2 on the initial entry to the loop,
the loop is not executed and control passes to the
next statement after statement n.
When the DO loop is satisfied, the index variable
i is no longer well defined. If a transfer out of the
DO loop occurs before the DO is satisfied, the
value of i is preserved and may be used in subse-
quent statements.
5.5.2 DO nests
When a DO loop contains another DO loop, the
grouping is called a DO nest. The last statement of
a nested DO loop must either be the same as the
last statement of the outer DO loop or occur before
it. If Dj,D 2 , . . . D m represent DO statements, where
the subscripts indicate that Di appears before D 2
appears before D 3 , and n 1; n,, . . . ,n m represent the
corresponding limits of the D 1; then n m must appear
before n m _! . . . n 2 must appear before m.
I-Di
Do
■D„
•
(start)
mi->i
EXECUTE STATE-
MENTS IN LOOP
INCLUDING
STATEMENT N.
i.+m 3 -»i
5-3
Examples:
DO loops may be nested in common with other DO
loops :
D,
D-
n 2
D,
DO 1 I = 1,10,2
D 3
Bi
Do
n 2
D„
ni
DO 100 L = 2,LIMIT
1 — D1
*->2
1 n -
-n.
= n 3
DO 5 I = 1,5
DO 5 J = 1,10
DO 5 K = J,15
D 3
DO 2 J = 1,5
DO 10 I = 1,10
DO 10 J = 1,10
5 CONTINUE
D0 3K- 2,8
3 CONTINUE
2 CONTINUE
DO 4 L = 1,3
4 CONTINUE
1 CONTINUE
10 CONTINUE
DO 20 K = K1,K2
20 CONTINUE
100 CONTINUE
f
5-4
d
•5.5.3 DO LOOP TRANSFER
In a DO nest, a transfer may be made from one DO
loop into a DO loop that contains it; and a transfer
out of a DO nest is permissible.
The special case is transferring out of a nested DO
loop and then transferring back to the nest. In a
DO nest, if the range of i includes the range of j
and a transfer out of the range of j occurs, then a
transfer into the range of i or i is permissible.
A transfer from the outer DO loop to the last state-
ment should not be made when that statement is also
the last statement of an inner DO loop. If such a
transfer is made, control will transfer to the inner DO
loop.
Example :
DO10I = J,K,L
5 GO to 10
DO10II = JJ,KK,LL
10 CONTINUE
This will cause control to pass the inner DO loop.
In the following diagram, EXTR represents a por-
tion of the program outside of the DO nest.
5.5.4 DO PROPERTIES
1. The indexing parameters mi,mo,m 3 may be any
executable arithmetic expression.
2. The indexing parameters m x and m 2 , if variable,
may assume positive or negative values, or zero.
3. The values of m 2 and m 3 may be changed during
the execution of the DO loop.
4. i is initially m^ As soon as i exceeds m», the loop
is terminated.
5. DO loops may be nested 50 deep.
5.6 CONTINUE
CONTINUE
The CONTINUE statement is most frequently used
as the last statement of a DO loop to provide a
transfer address for IF and GO TO instructions that
are intended to begin another repetition of the loop.
If CONTINUE is used elsewhere in the source pro-
gram, it acts as a do-nothing instruction; and control
passes to the next sequential program statement.
5.7 PAUSE
PAUSE
PAUSE n
PAUSE or PAUSE n act as do-nothing instructions.
5.8 STOP
STOP
STOP n
STOP or STOP n cause immediate exit to the
monitor, n is an arbitrary number, not more than 5
digits in length.
5.9 END
END
END marks the physical end of a program or sub-
program. It is executable in the sense that it effects
return from a subprogram in the absence of a
RETURN.
The END statement may include the name of the
program or subprogram which it terminates. This
name, however, is ignored .
The END statement is not connected widi the dollar
sign, which is used as a separator, nor does it make
use of the continuation. When punched into a card,
it must be the only entry in the card and must be
punched within columns 7 through 72.
5-5
i
i)
(
•
6. FUNCTIONS AND SUBPROGRAMS
5 ^y
Sets of instructions may be written as independent
subroutines or function subprograms which can be
referred to by the main program. The mode of a
function subprogram is determined by the name of
the subroutine in the same manner as variable
modes are determined. Subroutine subprogram
names are not classified by mode. The program or
function name must be unique within that sub-
program.
6.1 MAIN PROGRAMS AND
SUBPROGRAMS
A main program may be written with or without
references to subprograms. In all cases, the first
statement must be of the following form where
name is an alphanumeric identifier, 1-8 characters.
The first character must be alphabetic; the remain-
ing characters may be alphabetic or numeric.
PROGRAM name
A main program may refer to both subroutines and
functions which are compiled independently of the
main program. A calling program is a main pro-
gram or subprogram that refers to subroutines and
functions.
6.2 FUNCTIONAL SUBPROGRAM
The first statement of function subprograms must
have the form:
FUNCTION F ( Pl , p 2 , . . . Pn )
F is the function name and the ps are formal
parameters. A function name is constructed and its
type determined in the same way as a variable
identifier. The parameters may be array names,
non-subscripted variables, or names of other func-
tion or subroutine subprograms. A function, together
with its arguments, may be used any place in an
expression that a variable identifier may be used.
A function reference is a call upon a computational
procedure for the return of a single value associated
with the function identifier. This procedure may be
defined by a single statement in the program
(arithmetic statement function), in the compiler
(library function), or in a multi-statement sub-
program compiled independently of a main pro-
gram (function subprogram).
The name of a function subprogram may occur as
an operand in an arithmetic statement. The function
reference must supply the function with at least one
argument and it may contain up to 63. The form of
the function reference is:
F (p l5 p,, . . . p n )
F is the function name and pj are function argu-
ments or actual parameters. The corresponding
arguments appearing with the function name in a
function definition are called formal parameters.
Because formal parameters are local to the sub-
program in which they appear, they may or may not
correspond to the actual parameters in the calling
subprogram.
Type-FUNCTION statements are permitted in ad-
dition to the FUNCTION F (p 1; p., . . . p n ) state-
ment where mode is determined by the first
character or a TYPE declaration. The alternate
forms are :
REAL FUNCTION F( Pl ,p 2 , . . . p n )
INTEGER FUNCTION F( Pl ,p = , . . . Pn )
DOUBLE PRECISION FUNCTION
F (p^po, . . . p n )
COMPLEX FUNCTION F (p Xj p 2) . . . p n )
LOGICAL FUNCTION F ( Pl ,p,, . . . p n )
F is the function name, and p* are formal param-
eters. The type-FUNCTION statement declares the
type of the result returned by the function.
Rules:
1. The type of the function is determined from the
naming conventions specified for variables in
section 4.1 or from the type-FUNCTION state-
ment.
2. The name of a function must not appear in a
DIMENSION statement. The name must appear,
however, at least once as any of the following:
the left-hand identifier of a replacement state-
ment
an element of an input list
an actual parameter of a subprogram call
3. No element of a formal parameter list may ap-
pear in a COMMON, EQUIVALENCE, DATA,
or EXTERNAL statement within the function
subprogram.
6-1
4. When a formal parameter represents an array,
it must be declared in a DIMENSION statement
within the function subprogram. If it is not de-
clared, only the first element of the array is avail-
able to the function subprogram.
5. In referring to a function subprogram the fol-
lowing forms of the actual parameters are per-
missible:
arithmetic expression
constant or variable, simple or subscripted
array name
function reference
subroutine
When the name of a function subprogram appears
as an actual parameter, that name must also appear
in an EXTERNAL statement in the calling program.
When the name of a function subprogram is used as
an actual parameter, it may be in either of two
forms :
a. FUNCTION PUSH (ARG1)
b. FUNCTION PUSH (FUNCT,ARG2)
To call these functions, then, the calling program
uses, respectively, the forms:
a. A = PUSH (CALC(X) )
b. A = PUSH (CALC, X)
When a subroutine appears as an actual parameter,
the subroutine name may appear alone or with a
parameter list. When a subroutine appears with a
parameter list, the subroutine name and its param-
eters must appear as separate actual parameters:
Level I— Calling program
PUSH = - -
END
At some other level of the program, subroutines
DAB and DABL are defined.
a
6. Logical expressions may be actual parameters.
7. Actual and formal parameters must agree in
order, number (see rule 5, section 6.7) and type.
8. Functions must have at least one parameter.
6.3 LIBRARY FUNCTIONS
Function subprograms which are used frequently
have been written and stored in a reference library
and are available to the programmer through the
compiler.
FORTRAN-66 contains the standard library func-
tions available in earlier versions of FORTRAN.
A list of these functions is in Appendix D. When
one appears in the source program, the compiler
identifies it as a library function and generates a
calling sequence within the object program.
In the absence of a TYPE declaration, the type of
the function identifier is determined by its first
letter or by the type-FUNCTION statement. How-
ever, for standard library functions the modes of the
results have been established through usage. The
compiler recognizes the standard library functions
and associates the established types with the results.
For example, in the function identifier LOGF, the
first letter, L, would normally cause that function
to return an integer result. This is contrary to estab-
lished FORTRAN usage. The compiler recognizes
LOGF as a standard library function and permits
the return of a real result.
A = PUSH (DAB,W,X)
B = PUSH (DABL,Y,Z)
Level II— Function statement and subroutine call
FUNCTION PUSH (SUB, ARG1, ARG2)
CALL SUB (ARG1, ARG2)
6.4 EXTERNAL STATEMENT
When the actual parameter list of a function or sub-
routine reference contains a function or subroutine
name, that name must be declared in an EX-
TERNAL statement. Its form is:
EXTERNAL identifier!, identifier 2 , . . .
Identifier! is the name of a function or subroutine.
The EXTERNAL statement must precede the first
executable statement of any program in which it
appears. When it is used, EXTERNAL always ap-
pears in the calling program; it must not be used
with arithmetic statement functions.
6-2
%
Examples:
1. Function Subprogram
FUNCTION GREATER (A,B)
IF (A.GT.B) 10,20
10 GREATER = A -B
RETURN
20 GREATER = A + B
END
Calling Program Reference
Z(I,J) = F1 + F2-GREATER(C-D,3.*I/J)
2. Function Subprogram
FUNCTION PHI(ALFA, PHI2)
PHI = PHI2(ALFA)
END
Calling Program Reference
EXTERNAL SINF
4. Function Subprogram
FUNCTION AL(W,X,Y,Z)
CALL w(x;y,z)
AL = Z**4
RETURN
END
Function Subprogram Reference
EXTERNAL SUM
G = AL(SUM,E,V,H)
In the function subprogram the name of the sub-
routine (SUM) and its parameters (E,V,H) replace
W and X,Y,Z. SUM appears in the EXTERNAL
statement so that the compiler treats it as a sub-
routine name rather than a variable identifier.
C = D-PHI(Q(K),SINF)
From its call in the main program, the formal
parameter ALFA is replaced by Q(K), and the
formal parameter PHI2 is replaced by SINF. PHI
will be replaced by the sine of Q(K).
3. Function Subprogram
FUNCTION PSYCHE (A,B,X)
CALL X
PSYCHE = A/B *2. * ( A - B)
END
Function Sumprogram Reference
EXTERNAL EROS
R = S- PSYCHE (TLIM, ULIM, EROS)
In the function subprogram, TLIM, ULIM replaces
A,B. The CALL X is a call to a subroutine named
EROS. EROS appears in an EXTERNAL statement
so that the compiler recognizes it as a subroutine
name rather than a variable identifier.
6.5 STATEMENT FUNCTIONS
Statement functions are defined when used as an
operand in a single arithmetic or logical statement
in the source program and apply only to the par-
ticular program or subprogram in which the defini-
tion appears. They have the form
F (p ljP o, . . . p n )
E
l^n^63
F is the function name, p, are the formal param-
eters, and E is an expression.
Rules:
1. The function name must not appear in a
DIMENSION, EQUIVALENCE, COMMON or
EXTERNAL statement.
2. The formal parameters usually appear in the
expression E. When the statement function is
executed, formal parameters are replaced by the
corresponding actual parameters of the function
reference. Each of the formal parameters may be
TYPE REAL or INTEGER only, but they may
not be declared in a TYPE statement. Each of the
actual parameters may be any computable
arithmetic expression, but there must be agree-
ment in order, number and type between the
actual and formal parameters. Formal parameters
must be simple variables.
6-3
3. E may be an arithmetic or logical expression.
4. E may contain subscripted variables.
5. The expression E may refer to library functions,
previously defined statement function and func-
tion subprograms.
6. All statement functions must precede the first
executable statement of the program or subpro-
gram, but they must follow all declarative state-
ments (DIMENSION, TYPE, et cetera).
Examples:
TYPE COMPLEX Z
Z ( X ,Y) = (1. ,0.)*EXPF(X)*COSF(Y)
+ (0.,1.)*EXPF(X)*SINF(Y)
This arithmetic statement function computes
the complex exponential Z(x,y) = e x+,y .
6.6 SUBROUTINE PROGRAM
A reference to a subroutine is a call upon a com-
putational procedure. This procedure may return
none, one or more values. No value is associated
with the name of the subroutine, and the subroutine
must be called by a CALL statement.
The first statement of subroutine subprograms must
have the form:
l^n^63
SUBROUTINE S
or
SUBROUTINE S (p l5 p„ . . . p„)
S is the subroutine name which follows the rules for
variable identifiers, and p, are the formal param-
eters which may be array names, non-subscripted
variables, or names of other function or subroutine
subprograms.
Rules:
1 The name of the subroutine may not appear in
any declarative statement (TYPE, DIMENSION)
in the subroutine.
2. No element of a formal parameter list may ap-
pear in a COMMON, EQUIVALENCE, DATA,
or EXTERNAL statement within the subroutine
subprogram.
4. When a formal parameter represents an array,
it must be declared in a DIMENSION statement
within the subroutine. If it is not declared, only
the first element of the array is available to the
subroutine.
6.7 CALL
The executable statement in the calling program for
referring to a subroutine subprogram is of the form:
CALL S
or
CALL S (p„p„...p„) l^n^63
S is the subroutine name, and pi are the actual
parameters. The CALL statement transfers control
to the subroutine. When a RETURN or END state-
ment is encountered in the subroutine, control is
returned to the next executable statement following
the CALL in the calling program. If the CALL
statement is the last statement in a DO, looping con-
tinues until satisfied. Subprograms may be called
from a main program or from other subprograms.
Any subprogram called, however, may not call the
calling program. That is, if program A calls sub-
program B, subprogram B may not call program A.
Furthermore, a program or subprogram may not
call itself.
Rules:
1. The subroutine returns values through formal
parameters which are substituted for actual
parameters or through common variables.
2. The subroutine name may not appear in any
declarative statement (TYPE, DIMENSION, et
cetera). No value is associated with its name.
3. In the subroutine call, the following forms of
actual parameters are permissible:
arithmetic expression
constant or variable, simple or subscripted
array name
function reference
subroutine or function name
logical expression
When the name of a function subprogram appears
as an actual parameter, that name must also appear
in an EXTERNAL statement in the calling program.
When the name of a function subprogram is used as
an actual parameter, it may be in either of two
forms:
a. FUNCTION POSH (ARG3)
b. FUNCTION POSH (FUNCT, ARG4)
6
6-4
•
To call these functions, then, the calling program
uses, respectively, the forms:
a. B = POSH (CALC(X) )
b. B = POSH (CALC,X)
When a subroutine appears as an actual param-
eter, the subroutine name may appear alone or with
a parameter list.
When a subroutine appears with a parameter list,
the subroutine name and its parameters must ap-
pear as separate actual parameters.
Level I— Calling program
6. Logical expressions may be actual parameters.
Examples:
1. Subroutine Subprogram
SUBROUTINE BLVDLDR (A,B,W)
W = 2.*B/A
END
Calling Program References
CALL BLVDLDR (X(I),Y(I),W)
A = PULL (DIS,A,B)
CALL BLVDLDR (X(I) + H/2. ,Y(I)
+ C(1)/2.,W)
B = PULL (DISP,C,D)
Level II— Function statement and subroutine call
FUNCTION PULL (SUB,ARG1,ARG2)
CALL SUB (ARG1, ARG2)
PULL = - -
END
Level III— Subroutine definition
SUBROUTINE DIS (DUMMY 1, DUMMY 2)
END
SUBROUTINE DISP (DUMMY 3, DUMMY 4)
CALL BLVDLDR (X(I) + H,Y(I) + C(3),Z)
Subroutine Subprogram (Matrix Multiply)
SUBROUTINE MATMULT
COMMON/BLK1/X(20,20),Y(20,20),
Z(20,20)
1 = 1,20
J = 1,20
DO 10
DO 10
Z(IJ)=0
DO 10
K = l,20
10 Z(IJ) = (IJ) + X(LK)*Y(K,J)
RETURN
END
Calling Program Reference
COMMON/BLK1/A(20,20),B(20,20),
C(20,20)
END
4. Because formal parameters are local to the sub-
routine in which they appear, they may be the
same as names appearing outside the subroutine.
5. Actual and formal parameters must agree in
order, type and, for the first call of the sub-
program, in number (example 4).
CALL MATMULT
6-5
3. Subroutine Subprogram
SUBROUTINE ISHTAR (Y,Z)
COMMON/1/X(100)
Z = 0.
DO 5 1 = 1,100
5 Z=Z+X(I)
CALL Y
RETURN
END
Calling Program Reference
COMMON/1/A(100)
EXTERNAL PRNTIT
CALL ISHTAR (PRNTIT,SUM)
6.8 PROGRAM ARRANGEMENT
FORTRAN-66 assumes that all statements and
comments appearing between a PROGRAM, SUB-
ROUTINE or FUNCTION statement and an END
statement belong to one program. A typical arrange-
ment of a set of main program and subprograms
follows.
/PROGRAM SOMTHING
^END
-SUBROUTINE SI
iEND
-SUBROUTINE S2
*END
6-6
-FUNCTION Fl (. ..)
\END
/FUNCTION F2 (. . .)
^END
6.9 RETURN AND END
A subprogram normally contains one or several
RETURN statements that indicate the end of logic
flow within the subprogram and return control to
the calling program. The form is:
RETURN
In function references, control returns to the state-
ment containing the function. In subroutine subpro-
grams, control returns to the calling program.
The END statement marks the physical end of a
program, subroutine subprogram or function sub-
program. If the RETURN statement is omitted,
END acts as a return to the calling program.
A RETURN statement in the main program causes
an exit to the monitor.
6.10 ENTRY
This statement provides alternate entry points to a
function or subroutine subprogram. Its form is:
ENTRY name
Name is an alphanumeric identifier, and may ap-
pear within the subprogram only in the ENTRY
statement. Each entry identifier must appear in a
separate ENTRY statement. The maximum number
of entry points, including the subprogram name, is
20. The formal parameters, if any, appearing with
the FUNCTION or SUBROUTINE statement do
not appear with the ENTRY statement. ENTRY
may appear anywhere within the subprogram ex-
cept it must not appear within a DO; it can not be
labeled.
In the calling program, the reference to the entry
name is made just as though reference were being
made to the FUNCTION or SUBROUTINE in
which the ENTRY is imbedded. Rules 5 and 6 of
6.2 apply.
ENTRY names must agree in type with the func-
tion or subroutine name.
<
Examples:
FUNCTION JOE (X,Y)
10 JOE=X+Y
RETURN
ENTRY JAM
IF(X.GT.Y)10,20
20 JOE=X-Y
END
This could be called from the main programi as
follows:
Z=A + B-JOE(3.*P,Q-l)
^P
R=S+JAM(Q,2.*P)
6.11 VARIABLE DIMENSIONS IN
SUBPROGRAMS
In many subprograms, especially those performing
matrix manipulation, the programmer may wish to
vary the dimension of the arrays each time the sub-
program is called.
This is accomplished by specifying the array identi-
fier and its dimensions as formal parameters in the
FUNCTION or SUBROUTINE statement head-
ing a subprogram. In the subroutine call from the
calling program, the corresponding actual param-
eters specified are used by the called subprogram.
The maximum dimension which any given array
may assume is determined by a DIMENSION state-
ment in the main program at compile time.
Rules:
1. The rules of 6.2, 6.5, and 6.7 apply.
2. The formal parameters representing the array
dimensions must be simple integer variables. The
array identifier must also be a formal parameter.
3. The actual parameters representing the array
dimensions may be integer constants or integer
variables.
4. If the total number of elements of a given array
in the calling program is N, then the total num-
ber of elements of the corresponding array in the
subprogram may not exceed N.
Examples:
1. Consider a simple matrix add routine written as
a subroutine:
SUBROUTINE MATADD(X,Y,Z,M,N)
DIMENSION X (M,N),Y(M,N),Z(M,N)
DO 10 I=1,M
DO 10 J=1,N
10 Z(IJ)=X(I,J)+Y(I,J)
RETURN
END
The arrays X,Y,Z and the variable dimensions
M,N must all appear as formal parameters in the
SUBROUTINE statement and also appear in the
DIMENSION statement as shown. If the calling
program contains the array allocation declaration
DIMENSION A(10,10), B(10,10), C(10,10)
DIMENSION D(4, 8), E(4, 8), F(4, 8)
DIMENSION P(3, 12), Q(3, 12), R(3, 12)
the program may call the subroutine MATADD
from several places within the main program,
varying the array dimension within MATADD
each time as follows:
CALL MATADD (A,B,C,10,10)
CALL MATADD (D,E,F,4,i
CALL MATADD (P,Q,R,3,12)
The compiler does not check to see if the limits of
the array established by the DIMENSION state-
ment in the main program are exceeded.
6-7
yn--
Y-21--
y a i • •
y« • •
Its transposed Y' is
Yin
y= n
y 3n
y*n
Y' =
Yii y2i y 3 i y«
y ln y=n y 3n y4n
The following 6600 FORTRAN program permits
variation of N from call to call :
SUBROUTINE MATRAN (Y, YPRIME, N)
DIMENSION Y(4,N), YPRIME (N, 4)
DO 7 I = 1,N
DO 7 J = l,4
7 YPRIME (IJ) = Y(J,I)
END
6-8
(..
•
7. FORMAT SPECIFICATIONS
Data transmission between storage and an external
unit requires the FORMAT statement and the I/O
control statement (Chapter 9). The I/O statement
specifies the input/output device and process—
READ, WRITE, and so forth, and a list of data to
be moved. The FORMAT statement specifies the
manner in which the data are to be moved. In binary
tape statements no FORMAT statement is used.
7.1 THE I/O LIST
The list portion of an I/O control statement indi-
cates the data elements and the order, from left to
right, of transmission. Elements may be simple
variables or array names (subscripted or non-sub-
scripted). They may be constants on output only.
List elements are separated by commas, and the
order must correspond to the order of the FOR-
MAT specifications.
7.1.1 TRANSMISSION OF ARRAYS
Part or all of an array can be represented as a list
item. Multi-dimensioned arrays may appear in the
list, with values specified for the range of the sub-
scripts in an implied DO loop.
The general forms are:
( a ) transmission by columns
( ( ( A ( I, J,K ),I = m l! m 2 ,m 3 )J = n^n^n,, ) ,
K=p l5 p 2 ,p 3 )
(b) transmission by rows
( ( ( A ( I, J,K ) ,K = pi,p 2 ,p 3 ) , J = rix.na.ng ) ,
I = m^mo.mg )
mi,ni,pi are any computable arithmetic expres-
sion. If m 3 , n 3 or p 3 is omitted, it is
construed as being 1.
I,J,K are subscripts of A. If a subscript is
omitted when transmitting an array, a
DO statement is generated for the
missing subscript using the entire
range of values.
The I/O list may contain nested DO loops to any
depth within the overall DO nest limit of 50 (in-
cluding the nest depth in which the I/O statement
resides ) .
Example:
DO loops nested 5 deep:
( ( ( ( (A(IJ,K),B(M), C(N), N = ni ,n 2 ,n 3 ),
M=mi,m,,m 3 ), K=k 1 ,k 2 ,k 3 ),
J = Ji>J2,j 3 ), I=ii,i 2 ,is)
During execution, each subscript (index variable)
is set to the initial index value: I = i x , J=ji, K=k 1;
M = m 1 , N=n x .
The first index variable defined in the list is incre-
mented first. Data named in the implied DO loops
are transmitted in increments according to the third
DO loop parameter until the second DO loop
parameter is exceeded. If the third parameter is
omitted, the increment value is 1. When the first
index variable reaches the maximum value, it is
reset; the next index variable to the right is incre-
mented; and the process is repeated until the last
index variable has been incremented.
An implied DO loop may also be used to transmit
a simple variable more than one time. In (A,K
= 1,10), A will be transmitted 10 times.
Example:
As an element in an input/output list, the expression
( ( (A(IJ,K),I = m 1 ,m 2 ,m 3 ), J = n 1; n 2 ,n 3 ),
K = pi,p 2 ,p 3 )
implies a nest of DO loops of the form
DO 10 K=p 1: p 2 ,p.,
DO 10 J=n 1; n 2 ,n 3
DO 10 I^m^m,,!!!,,
Transmit A(I,J,K)
10 CONTINUE
To transmit the elements of a 3 by 3 matrix by
columns :
((A(I,J),I = 1,3),J=1,3)
To transmit the elements of a 3 by 3 matrix by
rows:
((A(I,J),J=1,3),I=1,3)
If a multi-dimensioned array name appears in a list
without subscripts, the entire array is transmitted.
For example, a multi-dimensioned, non-subscripted
list element, SPECS, with an associated DIMEN-
SION SPECS (7,5,3) statement is transmitted as
though under control of the nested DO loops.
DO 10 K=l,3
DO 10 J = 1,5
7-1
DO 10 1 = 1,7
Transmit SPECS(IJ,K)
10 CONTINUE
or as though under control of an implied DO loop,
..,(((SPECS(IJ,K),I = 1,7),J=1,5),
K = l,3),...
I/O Lists:
( (BUZ(K,2*L),K = 1,5), L = l, 13,2)
Q(3), Z(2,2), (TUP(3*I-4), 1=2,10)
(RAZ(K), K=l, LIM1, LIM2)
7.2 FORMAT STATEMENT
The BCD I/O control statements require a FOR-
MAT statement which contains the specifications
relating to the internal- external structure of the
corresponding I/O list elements.
FORMAT (spec,, . . . ,k(spec m , . . . ),spec n , . . . )
Speci is a format specification and k is an optional
repetition factor which must be an unsigned integer
constant. The FORMAT statement is non-execut-
able, and may appear anywhere in the program.
7.3 FORMAT SPECIFICATIONS
The data elements in I/O lists are converted from
external to internal or from internal to external
representation according to FORMAT conversion
specifications. FORMAT specifications may also
contain editing codes.
FORTRAN-66 conversion specifications
Ew.d Single precision floating point
with exponent
Fw.d Single precision floating point
without exponent
Dw.d Double precision floating point
with exponent
C(Zw.d,Zw.d) Complex conversion; Z may be
E or F conversion
Iw Decimal integer conversion
Ow Octal integer conversion
Aw Alphanumeric conversion
R w Alphanumeric conversion
Lw Logical conversion
n P Scaling factor
FORTRAN-66 editing specifications
W X Intra-line spacing
wH
7-2
;'}
Heading and labeling
/ Begin new record
n/ Create n-1 blank records.
Both w and d are unsigned integer constants, w
specifies the field width, the number of character
positions in the record; and d specifies the number
of digits to the right of the decimal within the field.
7.4 CONVERSION SPECIFICATIONS
7.4.1 EW.D OUTPUT
E conversion is used to convert floating point num-
bers in storage to the BCD character form for out-
put. The field occupies w positions in the output
record; the corresponding floating point number
will appear right justified in the field as
I Aa.a aE±eee -307^eee^307
«•« a are the most significant digits of the
integer and fractional part and eee are the digits
in the exponent. If d is zero or blank, the decimal
point and digits to the right of the decimal do not
appear as shown above. Field w must be wide
enough to contain the significant digits, signs, deci-
mal point, E, and the exponent. Generally, w is
greater than or equal to d + 7.
If the field is not wide enough to contain the output
value, asterisks are inserted for the entire field. If
the field is longer than the output value, the quan-
tity is right justified with blanks in the excess posi-
tions to the left.
For P-scaling on output, see section 7.6.2.
Examples:
A contains — 67.32 or +67.32
PRINT 10, A
10 FORMAT (E11.3)
Result: -6.732E + 001or6.732E + 001
PRINT 20, A
20 FORMAT (E14.3)
Result: aaa -6.732E + 001 or aaaa 6.732E + 001
A contains — 67.32
PRINT 30, A
30 FORMAT (E 10.3)
Result: ********** p rov ision not made for
sign
PRINT 40, A
40 FORMAT (E 11.4)
Result: *********** Same as above
#
9
7.4.2 EW.D INPUT
The E specification converts the number in the in-
put field (specified by w) to a real and stores it in
the appropriate location in memory.
Subfield structure of the input field:
input field
, A „
integer
fraction
exponent
The total number of characters in the input field
is specified by w; this field is scanned from left to
right; blanks within the field are interpreted as
zeros.
The coefficient subfield, composed of an integer
and/or a fraction, begins with a sign ( + or — ) or a
digit and contains a string of digits (a sequence of
consecutive numbers). The fraction portion which
begins with a decimal point contains a string of
digits. The subfield is terminated by a D, E, a +
or — , or the end of the input field.
An exponent subfield begins with a D, E, a + or a — .
When it begins with E or D, the + or — appears
between the E or D and the string of digits in the
subfield. The value of this string of digits must be
less than 310.
Permissible subfield combinations:
+ 1.6327E -04
-32.7216
+328+5
.629E -1
+ 136
.07628431
E -06 (interpreted
as zero)
Rules:
integer fraction exponent
integer fraction
integer exponent
fraction exponent
integer only
fraction only
exponent only
In the Ew.d input specification, d acts as a nega-
tive power of ten scaling factor when the decimal
point is not present. The internal representation
of the input quantity will be:
(integer subfield) xl0- d X10 (expanent s "" tieId >
For example, if the specification is E7.8, the input
quantity 3267 + 05 is converted and stored as:
3267 X10- 8 X10 5 = 3.267.
2. If E conversion is specified, but a decimal point
occurs in the input constants, the decimal point
will override d. The input quantity 3.67294 + 5
may be read by any specification but is always
stored as 3.67294 X10 5 .
3. When d does not appear, it is assumed to be zero.
4. The field length specified by w in Ew.d must
always be the same as the length of the input
field containing the input number. When it is not,
incorrect numbers may be read, converted and
stored as shown below. The field w includes the
significant digits, signs, decimal point, E, and
exponent.
READ 20,A,B,C
20 FORMAT (E9.3,E7.2,E10.3)
The input quantities appear on a card in three con-
tiguous field columns 1 through 24:
L — 9 „_L-5-J» io «4
+ 6.47E-01-2.36 + 5.321E + 02
The second specification (E7.2) exceeds the physical
field width of the second value by two characters.
Reading proceeds as follows:
— 7-
-10
"I
I + 6.47E-0U -2.36 + 5.321E + 02
+ 6.47E - 01 1-2.36 + 51 321E + 02
+ 6.47E-01-2.36 + 5 |.321E + 02 aa|
First +6.47E — 01 is read, converted and placed in
location A.
7-3
Next, —2.36 + 5 is read, converted and placed in
location B. The number actually desired was —2.36,
but the specification error (E7.2 instead of E5 2)
caused the two extra characters to be read. The
number read ( — 2.36 + 5) is a legitimate input repre-
sentation under the definitions and restrictions.
Finally .321E + 02 AA is read, converted and placed
in location C. Here again, the input number is legiti-
mate; and it is converted and stored, even though it
is not the number desired.
The above example illustrates a situation where
numbers are incorrectly read, converted, and stored,
and yet there is no immediate indication that an
error has occurred.
Examples:
Ew.d Input
Input Field
Specifi-
cation
+ 143.26E-03 E11.2
-12.437629E + 1 E13.6
8936E + 004 E9.10
327.625 E7.3
4.376 E5
-.0003627 + 5 E11.7
-.0003627E5 E11.7
blanks
1E1
E + 06
E 1
Ew.d
E3.0
E6.3
Converted
Value
.14326
-124.37629
.008936
327.625
4.376
-36.27
-36.27
-0.
10.
E10.6 0.
10.
Remarks
All subfields
present
All subfields
present
No fraction
subfield. In-
put number
converted as
8936. X
io- Mt4
No exponent
subfield
No d in spec-
ification
Integer sub-
field contains
— only
Integer sub-
field contains
— only
All subfields
empty
No fraction
subfield. In-
put number
converted as
1. X 10 1
No integer or
fraction sub-
field. Zero
stored regard-
less of expo-
nent field
contents
Blanks are
interpreted as
zeros
7.4.3 FW.D OUTPUT
The field occupies w positions in the output record;
the corresponding list element must be a floating
point quantity, and it will appear as a decimal num-
ber; right justified in the field w, as:
± 8 ... 8 .8 ... S
8 represents the most significant digits of the num-
ber. The number of places to the right of the deci-
mal point is specified by d. If d is zero or omitted,
the fractional digits do not appear. If the number is
positive, the + sign is suppressed.
If the field is too short to accommodate the num-
ber, asterisks will appear in the output field.
If the field w is longer than required to accommo-
date the number, it is right justified with blanks
occupying the excess field positions to the left.
Examples:
A contains +32.694
PRINT 10,A
10 FORMAT(F7.3)
Result: a 32.694
PRINT 11,A
11 FORMAT(F10.3)
Result: aaaa 32.694
A contains -32.694
PRINT 12,A
12 FORMAT(F6.3)
Result: ****** no provision for — sign
7.4.4 FW.D INPUT
This specification is a modification of Ew.d. The
input field consists of an integer and a fraction sub-
field. An omitted subfield is assumed to be zero. All
rules listed under Ew.d input apply. P-scaling is
permissible.
7-4
#
#
Examples:
Fw.d Input
Specifi-
Converted
Input Field
cation
Value
Remarks
367.2593
F8.4
367.2593
Integer and
fraction field
37925
F5.7
.0037925
No fraction
subfield. In-
put number
converted as
37925 X 10" T
-4.7366
F7
-4.7366
No d in spec-
ification
.62543
F6.5
.62543
No integer
subfield
.62543
F6.d
.62543
Decimal
point over-
rides d of
specification
+ 144.15E-03
F11.2
.14415
Exponents
are legitimate
in F input
and may have
P-scaling
7.4.5 DW.D OUTPUT
The field occupies w positions of the output record;
the corresponding list element which must be a
double precision quantity appears as a decimal
number, right justified in the field w:
Aa.a . . . a E ± eee -307^eee^307
D conversion corresponds to Ew.d output except
that 29 is the maximum number of significant digits
in the fraction.
7.4.6 DW.D INPUT
D conversion corresponds to Ew.d input except that
29 is the maximum number of significant digits
permitted in the combined integer-fraction field.
P-scaling is not applicable. D is acceptable in place
of E as the beginning of an exponent field.
Example:
TYPE DOUBLE Z,Y
READ1, Z,Y
1 FORMAT (D24.17,D15)
Input card:
.col. 1,
' -6.31675298443769217E-03
f 24 *
2.718926453147'
i 15 ■
7.4.7 C (Z1W1.Di.Z2W2.D2) OUTPUT
Z is either E or F. The field occupies Wi + w a posi-
tions in the output record, and the corresponding
list element must be complex. w t + w. are two real
values; w t represents the real part of the complex
number and \v-, represents the imaginary part. The
value may be one of the following forms :
A8.8 ... 8 Exp.AS.8 . . . S Exp. (Ew.d.Ew.d)
AS. 8 . . . 8 Exp.AS . . . S.8 . . . 8 (Ew.d.Fw.d)
.8. 8 . . . 8A8.8 ... 8 Exp.
. 8.8 . . .8A8 ... 8.8 .. .8
(Fw.d.Ew.d)
(Fw.d.Fw.d)
AS ..
A8 .
Exp is ± e^ej.
The restrictions for Ew.d and Fw.d apply.
If spaces are desired between the two output num-
bers, the second specification should indicate a
field (w 2 ) larger than required.
Example:
TYPE COMPLEX A
PRINT 10,A
10 FORMAT (C(F7.2,F9.2) )
real part of A is 362.92
imaginary part of A is —46.73
Result: A 362.92 AAA - 46.73
7.4.8 C (Z1Wj.D1.Z2W2.D2) INPUT
Z is either E or F and the input quantity occupies
Wi +w 2 character positions. The first w t characters
are the representation of the real part of the com-
plex number, and the remaining w. characters are
the representation of the imaginary part of the com-
plex number.
The restrictions for Ew.d and Fw.d apply.
7-5
Example:
TYPE COMPLEX A,B
READ 10,A,B
10 FORMAT (C(F6.2,F6.2), C(E10.3,E10.3) )
Input card:
The input field w which consists of an integer sub-
field may contain only the characters +, — , the
digits through 9, or blank. When a sign appears,
it must precede the first digit in the field. Blanks
are interpreted as zeros. The value is stored right
justified in the specified variable.
col. 1
-42.13 + 13.91 + 1.456E + 03-1.216E-01
U— 6-1—6-
-10
10-
7.4.9 1W OUTPUT
I specification is used to output decimal integer
values. The output quantity occupies w output rec-
ord positions; it will appear right justified in the
field w, as:
AS ... S
8 is the most significant decimal digits (maximum
18) of the integer. If the integer is positive, the +
sign is suppressed.
If the field w is larger than required, the output
quantity is right justified with blanks occupying
excess positions to the left. If the field is too short,
characters are discarded from the left.
Example:
PRINT 10,IJ,K
10 FORMAT (18,110,15)
Result:
I contains -3762
J contains +4762937
K contains +13
AAA -3762 AAA 4762937 AAA 13
■10-
»5-~
7.4. lO IW INPUT
The field is w characters in length and the corre-
sponding list element must be a decimal integer
quantity.
7-6
Example:
READ 10,I,J,K,L,M,N
10 FORMAT (13,17,12,13,12,14)
Input card:
col. 1
139AA-15AA18 AA7A3A1A4 \
—I 3 U 7 — -U l—3»| 2 [—4—1
In memory:
I contains 139
J -1500
K 18
L 7
M 3
N 104
7.4.11 OW OUTPUT
O specification is used to output octal integer values.
The output quantity occupies w output record posi-
tions, and it will appear right justified in the field
as: S S ... 8.
The 8 are octal digits. If w is 20 or less, the right-
most w digits appear. If w is greater than 20, the
number is right justified in the field with blanks to
the left of the output quantity. A negative number
is output in its machine form (one's complement).
7.4.12 ow INPUT
Octal integer values are converted under O specifi-
cation. The field is w octal integer characters in
length and the corresponding list element must be
an integer quantity.
The input field w consists of an integer subfield
only (maximum of 20 octal digits). The only char-
acters that may appear in the field are +, or — ,
blank and through 7. Only one sign is permitted;
it must precede the first digit in the field. Blanks
are interpreted as zeros.
Example:
TYPE INTEGER P,Q,R
READ 10,P,Q,R
10 FORMAT (010,012,02)
w^lO output
w>10 input
■w
field
10
Input Card:
i
" 3737373737666 A 6644 A 444-0 \
L, 10 -»-i-« 12 ■- 2 L»-
In memory: P:
Q:
R:
00000000003737373737
00000000666066440444
77777777777777777777
A negative number is represented in complement
form.
A negative octal number is represented internally
in 20-digit seven's complement form obtained by
subtracting each digit of an octal number from
seven. For example, if —703 is an input quantity,
its internal representation is 77777777777777777074.
That is,
77777777777777777777
- 00000000000000000703
77777777777777777074
7.4.13 AW OUTPUT
A conversion is used to output alphanumeric char-
acters. If w is 10 or more, the output quantity ap-
pears right justified in the output field, blanks fill to
left. If w is less than 10 the output quantity repre-
sents the leftmost w characters, left justified in the
field.
7.4.14 AW INPUT
This specification will accept as list elements any
set of six bit characters including blanks. The in-
ternal representation is BCD; the field width is w
characters.
If w exceeds 10, the input quantity will be the right-
most characters. If w is 10 or less, the input quantity
goes to the designated storage locations as a left
justified BCD word, the remaining spaces are blank-
filled.
memory
10 BCD characters
w<10 output
w==10 input
10
field
memory
w BCD char.
suppressed
char, or blanks
Example: (Compare with next example)
READ 10,Q,P,O
10 FORMAT (A10,A10,A4)
Input card :
col. 1
LUX MENTIS LUX ORBIS LUX \
II I
-«■ 10 — » ■ « 4 ♦!
In memory:
Q
p
o
LUXbMENTIS
bLUXbORBIS
bLUXbbbbbb
7.4.15 RW OUTPUT
This specification is the same as the Aw specifica-
tion with the following exception. If w is less than
10 the output quantity represents the rightmost
characters.
7-7
7.4.16 RW INPUT
If w is less than 10, the input quantity goes to the
designated storage location as a right justified bi-
nary zero filled word.
w=^10 output
w>10 input
field
10
memory
10 BCD char.
w<10 output
w^lO input
10
field
■w-
memory
zeros w BCD char.
Example: (Compare with previous example)
READ 10,Q,P,O
10 FORMAT (R10,R10,R4)
Input card:
col. 1
''lux mentis lux orbis lux X
H 10 -4- 10 — "4-4-H
7.4.17 LW OUTPUT
L specification is used to output logical values. The
input/output field is w characters long and the cor-
responding list element must be a logical element.
If w is greater than 1, 1 or is printed right justified
in the field w with blank fill to the left.
Example:
TYPE LOGICAL IJ,K,L
PRINT 5,IJ,K,L
5 FORMAT (4L3)
I contains 1
J contains
K contains 1
L contains 1
Result:
AA^AA^ AA 1 AA 1
7.4.18 LW INPUT
This specification will accept logical quantities as
list elements. A zero or a blank in the field w is
stored as zero. A one in the field w is stored as one.
Only one such character (0 to 1) may appear in any
input field. Any character other than 0, 1, or blank
is incorrect.
7.5 EDITING SPECIFICATIONS
7.5.1 wx
This specification may be used to include w blanks
in an output record or to skip w characters on input
to permit spacing of input/output quantities.
Examples:
PRINT 10,A,B,C A contains 7
10 FORMAT B contains 13.6
( I2,6X,F6.2,6X,E13.5 ) C contains 1462.37
Result ^7^6-^ ft 13.60<-6-* A 1.46237E + 003
READ 11,R,S,T
11 FORMAT(F5.2,3X, F5.2,6X,F5.2) or
FORMAT (F5.2,3XF5.2,6XF5.2)
Input card:
col. 1
14.62 AA $13.78 A COST A 15.97 'l T = 15.
In memory: R = 14.62
S = 13.78
97
In memory:
Q
p
o
LUXbMENTIS
bLUXbORBIS
OOOOOObLUX
In the specification list, the comma following X is
optional.
7-8
7.5.2 WH OUTPUT
This specification provides for the output of any set
of six-bit characters, including blanks, in the form
of comments, titles, and headings, w is an unsigned,
integer specifying the number of characters to the
right of the H that will be transmitted to the output
record. H denotes a Hollerith field. The comma fol-
lowing the H specification is optional.
Examples:
Source program:
PRINT 20
20 FORMAT(28H BLANKS COUNT IN AN H
FIELD.)
produces output record:
a BLANKS COUNT IN AN H FIELD.
Source program:
PRINT 30,A A contains 1.5
30 FORMAT(6H LMAX=,F5.2)
comma is optional
produces output record:
a LMAX = A 1.50
7.5.3 WH INPUT
The H field may be used to read a new heading
into an existing H field.
Example:
Source program:
READ 10
10 FORMAT (27H AAAAAAAAAAAAAAAAAAAAAAAAAAA
)
A THIS IS A VARIABLE HEADING
27 cols
After die READ, die FORMAT statement labeled
10 will contain the alphanumeric information read
from the input card; a subsequent reference to
statement 10 in an output control statement would
act as follows:
PRINT 10 produces die printer line:
a THIS IS A VARIABLE HEADING
7.5.4 *N CHAR.* OUTPUT
This specification can be used as an alternate form
of wH to output headings, titles, and comments.
Any 6-bit character (except asterisk) between the
asterisks will be output. Tile first asterisk denotes
the beginning of the Hollerith field; the second
asterisk terminates the field.
Examples:
1. Source program:
PRINT 10
10 FORMAT (*a SUBTOTALS*)
produces the output records: SUBTOTALS
2. If an asterisk accidentally occurs in the char-
acters to be output, it will terminate the field and
the characters following die asterisk will be inter-
preted as incorrect format specifications.
Source program:
PRINT 10
10 FORMAT (*ABC*BE*)
produces the output record: ABC The conver-
sion routine will attempt to interpret BE as a
format specification.
7.5.5
, * INPUT
This specification is used in place of wH to read a
new heading into an existing Hollerith field. Char-
acters are stored in the heading until an asterisk is
encountered in the input field or until all the spaces
in the format specification are filled. If the format
specification contains n spaces and the mth charac-
tem (m<n) in the input field is an asterisk, all char-
acters to the left of the asterisk will be stored in the
heading and the remaining character positions in
the heading will be filled with blanks.
Examples:
1. Source program:
READ 10
10 FORMAT (*aaaaaaaaaaaaaaaaaaaa*)
Input card: [FORTRAN FOR THE
6600
A subsequent reference to statement 10 in an
output control statement:
PRINT 10 produces:
FORTRAN FOR THE 6600
7-9
2. Source program:
READ 10
10 FORMAT (*AAAAAAA :
: )
Input card: f / HEAD*LINE
PRINT 10 produces: HEADaaa
7.5.6 NEW RECORD
The slash, /, which signals the end of a BCD record
may occur anywhere in the specifications list. It
need not be separated from the other list elements
by commas; consecutive slashes may appear in a list.
During output, it is used to skip lines, cards, or tape
records. During input, it specifies that control passes
to the next record or card, k + 1 consecutive slashes
produce k blank lines, or n/ produces n-1 blank lines
during output and skips n-1 records or cards during
input.
Examples:
PRINT 10
10 FORMAT (20X,7HHEADING///6X,
5HINPUT,19X,6HOUTPUT)
Print-out: HEADING me 2
line 2
line 3
INPUT OUTPUT line 4
Statement 10 in the example may also be written:
10 FORMAT (20X, 7HHEADING3/6X,
5HINPUT, 19X,6HOUTPUT)
Each line corresponds to a BCD record. The second
and third records are null and produce the line
spacing illustrated.
Internally:
A =-11.6 C= 46.327
B= .325 D= -14.261
PRINT 11,A,B,C,D
11 FORMAT (2E12.2/2F7.3)
Result: aa -1.16E + 001aaa3.25E-001
a 46.327 -14.261
PRINT 11,A,B,C,D
11 FORMAT (2E12.2/ /2F7.3)
Result: aa -1.16E + 001aaa3.25E-001
a 46.327 -14.261
PRINT 15, (A(I), = 1,9)
15 FORMAT (8HRESULTS2/(3F8.2)) )
Result:
RESULTS
7-10
3.62
-4.03
-9.78
-6.33
7.12
3.49
6.21
-6.74
-1.18
7.6 NP SCALE FACTOR
A scale factor may precede the F conversion and
E conversion. The scale factor is: External number
= Internal number X10 Bcale faGtor . The scale factor
applies to Fw.d on both input and output and to
Ew.d and Dw.d on output only. A scaled specifica-
tion is written as:
y
nP
w.d
n is a signed integer constant. The nP specifi-
cation may appear with complex conversion,
C(Zw.d,Zw.d); each word is scaled separately
according to Fw.d or Ew.d scaling.
7.6.1 FW.D SCALING
Input
The number in the input field is divided by 10 n
and stored. For example, if the input quantity
314.1592 is read under the specification 2PF8.4, the
internal number is 314.1592X10" 2 = 3.141592.
Output
The number in the output field is the internal num-
ber multiplied by 10". In the output representation,
the decimal point is fixed; the number moves to the
left or right depending on whether the scale factor
is plus or minus. For example, the internal number
3.1415926536 may be represented on output under
scaled F specifications as follows:
Specification Output Representation
F13.6 3.141593
1PF13.6 31.415927
3PF13.6 3141.592654
-1PF13.6 .314159
7.6.2 EW.D SCALING
Output
The scale factor has the effect of shifting the output
number left n places while reducing the exponent
by n. Using 3.1415926538 some output representa-
tions corresponding to scaled E-specifications are:
Specification Output Representation
E20.2 3.14E+000
1PE20.2 31.42E-001
2PE20.2 314.16E-002
3PE20.2 3141.59E-003
4PE20.2 31415.93E-004
5PE20.2 314159.27E-005
-1PE20.2 0.31E + 001
*
7.6.3 SCALING RESTRICTIONS
The scale factor is assumed to be zero if no other
value has been given; however, once a value has
been given, it will hold for all D,E and F specifi-
cations following the scale factor within the same
FORMAT statement. To nullify this effect in sub-
sequent D,E and F specifications, a zero scale factor,
P, must precede a D,E, or F specification. Scale
factors on D or E input specifications are ignored.
The scaling specification nP may appear independ-
ently of an E or F specification, but it will hold for
all E and F specifications that follow within the
same FORMAT statement unless changed by an-
other nP.
(3P, 319, F10.2) same as
(319, 3PF10.2)
7.7.1 UNLIMITED GROUPS
FORMAT specifications may be repeated without
the use of a repetition factor. The innermost paren-
thetical group that has no repetition factor is un-
limited and will be used repeatedly until the I/O
list is exhausted. Parentheses are the controlling
factors in repetition. The right parenthesis of an
unlimited group is equivalent to a slash. Specifica-
tions to the right of an unlimited group can never
be reached.
The following are format specifications for output
data:
(E16.3,F20.7,(2I4,2(I3,F7.1)),F8.2)
Print fields according to E16.3 and F20.7. Since
2(I3,F7.1) is a repeated parenthetical group, print
fields according to (2I4,2)I3,F7.1) ), which does not
have repetition operator, until the list elements are
exhausted. F8.2 will never be reached.
#
7.7 REPEATED FORMAT
SPECIFICATIONS
Any FORMAT specification may be repeated by
using an unsigned integer constant repetition fac-
tor, k, as follows: k(spec), spec is any conversion
specification except nP. For example, to print two
quantities K,L:
PRINT 10 K,L
10 FORMAT (12,12)
Specifications for K,L are identical; the FORMAT
statement may be: 10 FORMAT (212).
When a group of FORMAT specifications repeats
itself, as in: FORMAT (E15.3,F6.1,I4,I4,E15.3,F6.1,
14,14), the use of k produces: FORMAT (2(E15.3,
F6.1,2I4) ).
The parenthetical grouping of FORMAT specifica-
tions is called a repeated group. Repeated groups
may be nested to 10 levels.
FORMAT ( ni (-n 2 ( n 10 ) )))))))))
Therefore, FORMAT statements like the following
example are legal.
FORMAT (1H1,5(25X,13(5X,F6.2) ) )
7.8 VARIABLE FORMAT
FORMAT lists may be specified at the time of
execution. The specification list including left and
right parentheses, but not the statement number or
the word FORMAT, is read under A conversion or
in a DATA statement and stored in an integer
array. The name of the array containing the speci-
fications may be used in place of the FORMAT
statement number in the associated input/ output
operation. The array name that appears with or
without subscript specifies the location of the first
word of the FORMAT information.
Examples:
1. Assume the following FORMAT specifications:
(E12.2,F8.2,I7,2E20.3,F9.3,I4)
This information could be punched in an input
card and read by a program such as :
DIMENSION IVAR(4)
READ 1, (IVAR(I),I = 1,4)
1 FORMAT(3A8,A6)
The elements of the input card will be placed in
storage as follows:
IVAR : (E12.2.F
IVAR + 1 : 8.2,17,2
IVAR + 2 : E20.3,F9
IVAR +3 : .3,I4)bb
7-11
A subsequent output statement in the same pro-
gram could refer to these FORMAT specifications
as:
PRINT IVAR(1),A,B,I,C,D,EJ
or
PRINT IVAR,A,B,I,C,D,EJ
This would produce exactly the same result as
the program:
-PRINT 10AAI,CAEJ ._ -— .
10 FORMAT (E12.2,F8.2,I7,2E20.3,F9.3,I4)
2. DIMENSION LAIS(4)
DATA (LAIS = 8H(E12.2,F8H8.2,2I7),
8H(F8.2,E1,8H2.2,2I7) )
Output statements:
When 1 = 1
PRINT LAIS (I),A,B,IJ
or
PRINT LAIS,A,B,IJ
This is also the same as:
PRINT 1,A,B,I,J
1 FORMAT (E12.2,F8.2,2I7)
When 1-3
PRINT LAIS (I),C,D,IJ
This is the same as :
PRINT 2,0,0,1,1
2 FORMAT (F8.2,E12.2,2I7)
♦
7-12
f
8. INPUT-OUTPUT STATEMENTS
Input-output statements transfer information be-
tween the memory unit and one of the following
external devices :
An 80 column card reader
An SO column card punch
A 136 column printer
A magnetic tape unit
The external unit, i, may be specified by an integer
variable or a constant, 1 ^ i ^ 49. Logical values are
established for physical units by SIPROS.
The FORMAT statement number for RCD data
transmission is represented by n; and may be the
statement number, a variable identifier or a formal
parameter. Binary data transmission does not re-
quire a FORMAT statement.
The input-output list is specified by L. Binary in-
formation is transmitted with odd parity checking
bits. BCD information is transmitted with even
parity checking bits.
8.1 WRITE STATEMENTS
PRINT n,L
Transfers information from the memory locations
given by the list (L) identifiers to the standard
output medium. This information is transferred as
line printer images in accordance with the FOR-
MAT specification n.
PUNCH n,L
transfers information from the memory locations
given by the list (L) identifiers to the standard
punch medium. This information is transferred as
card images in accordance with the FORMAT speci-
fication n.
WRITE (i,n)L
and WRITE OUTPUT TAPE i,n,L are equivalent
forms which transfer information from memory to
a specified unit (i) using the number of list (L)
elements and the FORMAT specification (n) to de-
termine the number of records that will be written
on that unit. Each logical record is one physical
record containing up to 136 characters; the infor-
mation is recorded in even parity (BCD mode).
WRITE(i)L
and WRITE TAPE i,L are equivalent forms which
transfer information from memory to a specified
unit (i) using the number of list elements (L) to
determine the number of logical records that will
be written on that unit. If there is only one physical
record in the logical record, the first word contains
the integer 1.
If there are n physical records in the logical record,
the first word of the first n — 1 physical records con-
tain zero; the first word of the nth physical record
contains the integer n. This first word indicates
how many physical records exist in a logical record,
and it is used in the BACKSPACE Statement. The
information is recorded in odd parity (binary mode).
If the LIST is omitted, the WRITE(i) statement
acts as a do-nothing.
Examples:
WRITE OUTPUT TAPE 10,20,A,B,C
20 FORMAT (3F10.6)
WRITE (10,20) Q1,Q2,Q3
DIMENSION A(260), B(4)
WRITE (10) A,B
DO 5 1=1, 10
5 WRITE TAPE 6,AMAX(I), (M(IJ)J = 1,5)
WRITE OUTPUT TAPE 4,21
21 FORMAT (33H THIS STATEMENT HAS
NO DATA LIST.)
8.2 READ STATEMENTS
READ n,L
reads one or more card images, converting the in-
formation from left to right, in accordance with
the FORMAT specification (n), and stores the con-
verted data in the memory locations named by the
list (L) identifiers. The images read may come from
80-column Hollerith cards, or from magnetic tapes,
prepared off-line, containing 80-character records
in BCD mode.
READ(i,n)L
and READ INPUT TAPE i,n,L are equivalent forms
which transfer information from a specified logical
unit (i) to memory locations named by the list (L)
identifiers. The number of list elements and the
FORMAT specifications must conform to the rec-
ord structure on the logical unit (up to 136 char-
acters in the BCD mode).
READ(i)L
and READ TAPE i,L are equivalent forms which
transfer information from a specified logical unit
(i) to memory. The number of words in the list
must be equal to or less than the number of words
in the record on the logical unit. A record read by
READ (i)L should be the result of a binary mode
WRITE statement. If the statement occurs without
a list, READ(i), the tape on unit i moves forward
one logical record.
Examples:
READ 10,A,B,C
10 FORMAT (3F10.4)
READ (2,13) (Z(K),K = 1,8)
13 FORMAT (F10.4)
READ INPUT TAPE 6,20, Q1,Q2,Q3,Q4
20 FORMAT (4E11.3)
READ (6) ( (A(IJ),I = 1,100)J=1,50)
READ TAPE 6, ( (A(IJ),I = 1,100)J = 1,50)
READ (5) (skip one logical record on unit 5)
8.3 BUFFER STATEMENTS
There are three primary differences between the
buffer I/O control statements and the read/write
I/O control statements.
1. The mode of transmission (BCD or binary) is
tacitly implied by the form of the read/write con-
trol statement. In a buffer control statement,
parity must be specified by a parity indicator.
2. The read/write control statements are associated
with a list, and in BCD transmission with a FOR-
MAT statement. The buffer control statements
are not.
3. A buffer control statement initiates data trans-
mission, and then returns control to the program,
8-2
permitting the program to perform other tasks
while data transmission is in progress.
In the descriptions that follow, these definitions
hold:
i logical unit number: integer constant or vari-
able.
p parity indicator: for even parity (BCD);
1 for odd parity (binary).
A variable identifier: first word of data block
to be transmitted.
B variable identifier: last word of data block
to be transmitted. The location represented
by A must be equal to or less than the loca-
tion represented by B.
BUFFER IN (i,p) (A,B)
transmits information from unit i in mode p to
memory locations A through B. If a magnetic tape
containing BCD records written by WRITE(i,n) is
used by BUFFER IN, only one physical record will
be read. If a magnetic tape written by WRITE(i) is
read by BUFFER IN, only one physical record is
read.
BUFFER OUT (i,p) (A,B)
transmits information from memory locations A
through B, to unit i in mode p. The physical rec-
ord written contains B— A + l words, or a maximum
of 512 words.
8.4 TAPE HANDLING STATEMENTS
The logical unit number, i, may be an integer vari-
able or constant.
REWIND i
rewinds the magnetic tape mounted on unit i. If
tape is already rewound, the statement acts as a
do-nothing.
BACKSPACE i
backspaces the magnetic tape mounted on unit i
one logical record. (A logical record is a physical
record; except for tapes written by a WRITE(i)L
statement). If tape is at load point (rewound) this
statement acts as a do-nothing.
END FILE i
writes an end-of-file on the magnetic tape mounted
on unit i.
<t
The tape handling statements cannot be used on the
standard input, standard output, or standard punch
media.
8.5 STATUS CHECKING STATEMENTS
IF(EOF,i)n 1: n 2
checks the previous read (write) operation to de-
termine if an end-of-file (end-of-tape) has been en-
countered on unit i. If it has, control is transferred
to statement n^ if not, control is transferred to
statement n 2 .
IF(IOCHECK,i)n 1 ,n 2
checks the previous read (write) operation to de-
termine if a parity error has occurred on unit i. If
it has, control is transferred to statement n^ if not,
control is transferred to statement n 2 .
IF(UNIT,i)n 1 ,n 2 ,n.„n 4
is the status checking statement used with buffer
control. It should always appear before the first
statement that uses any of the variables transferred
in the buffer mode to avoid loss of information.
The n,- are statement numbers and the following
criteria apply:
Check the status of the last buffering operation on
unit i and transfer control to statement
n x if buffer operation is not complete
n, if buffer operation is complete and NO error oc-
curred
n 3 if buffer operation is complete and an EOF or
EOT occurred
rii if buffer operation is complete and parity or buf-
fer length errors occurred.
A buffer length error occurs on read only to indi-
cate that a record of length k words has been read
into a buffer area where word length is greater
than k.
Program
5 GO TO (50,4)J
Example:
Program
1 = 1
BUFFER IN (10,0) (A,Z)
4 IF(UNIT,10)5,6,7,8
Remarks
Set flag = 1
Initiate buffered read in
even (BCD) parity.
Check status of buffered
transfer.
Remarks
Not finished. Do calcula-
tions at 50.
50
{Some computation ^
not involving infor- \
mation in locations (
A-Z '
J = J + 1
GO TO 4
7 PRINT 70
70 FORMAT(12H EOF
UNIT 10)
GO TO 200
8 PRINT 80
80 FORMAT(35H
PARITY OR BUF
LENGTH ERROR
UNIT 10)
200 REWIND 10
STOP
6 CONTINUE
Calculations complete;
increase flag by 1. Go to 4.
End-of-file error.
Rewind tape and stop.
Stop.
Buffer transmission
complete.
Continue program.
8.6 ENCODE/DECODE STATEMENTS
The ENCODE/DECODE statements are compa-
rable to the WRITE/READ statements, the essential
difference being that no peripheral equipment is
used in the data transfer. Information is transferred
under FORMAT specifications from one area of
memory to another.
In the following descriptions, n and L have the
same meanings as were defined for input-output
statements.
c is an integer constant or integer variable spec-
ifying the record length (characters).
V is a variable identifier or an array identifier.
ENCODE (c,n,V)L
The information of the list variables (L) is converted
according to the n FORMAT statement and stored
in the locations identified by V.
DECODE (c,n,V)L
8-3
The information in the locations identified by V is
converted according to the n FORMAT statement
and stored in the list variables (L).
Example:
1. The following is one method of packing the
partial contents of two words into one word. In-
formation is stored in core as follows:
LOC(l)SSSSSxxxxx
LOC(6)xxxxxaaaaa 10 BCD ch/wd.
To form SSSSSaaaao: in storage location NAME:
DECODE(10,1,LOC(6) )TEMP
1 FORMAT(5X,A5)
ENCODE(10,2,NAME) LOC(l),TEMP
2 FORMAT(2A5)
The DECODE statement places the last 5 BCD
characters of LOC(6) into the first 5 characters of
TEMP. The ENCODE statement packs the first 5
characters of LOC(l) and TEMP into NAME.
A more straightforward way of accomplishing this
is with masking statements. Using the R specifica-
tion, the program may be shortened to:
ENCODE (10,1,NAME) LOC(l),LOC(6)
1 FORMAT (A5.R5)
I. DECODE may be used to calculate a field defini-
tion in a FORMAT specification at object time.
Assume that in the statement FORMAT (2A10,
Im) the programmer wishes to specify m at some
point in the program, subject to the restriction
2 ^= m — 9. The following program permits m to
vary.
IF(M .LT. 10 AND. M .GT. 1)1,2
1 ENCODE (10,100,SPECMAT) M
100 FORMAT (7H(2A10,I,I1,1H) )
PRINT SPECMAT,A,B,J
M is tested to insure it is within limits. If not,
control goes to statement 2 which could be an error
routine. If M is within limits, ENCODE packs the
integer value of M with the characters: (2A10,I).
This packed FORMAT is stored in SPECMAT.
SPECMAT contains (2A10,Im).
The print statement will print A and B under speci-
fication A10, and the quantity J under specification
12 ,or 13 or ... or 19 according to the value of m.
f
8-4
#
APPENDIX
A. CODING PROCEDURES
CODING FORM
FORTRAN-66 forms contain 80 columns in which
the characters of the language are written, one
character per column.
All comment cards belonging to a specific pro-
gram, or subprogram, should appear between the
PROGRAM, SUBROUTINE, or FUNCTION state-
ment and the END statement.
STATEMENTS
The statements of FORTRAN-66 are written in
columns 7 through 72. Statements longer than 66
columns may be carried to the next line by using
a continuation designator. More than one state-
ment may be written on a line. Blanks may be used
freely in FORTRAN statements to provide readi-
bility. Blanks are significant, however, in H fields.
STATEMENT SEPARATOR $
The special character $ may be used to write
more than one statement on a line. Statements so
written may also use the continuation feature. A $
symbol may not be used as a statement separator
with FORMAT statements or continuations of
FORMAT statements.
These statements are equivalent:
1 = 10
JLIM = 1
K = K + 1
GO TO 10
I=10$JLIM = 1$
K=K+l$GOTO10
DOlI = l,10$A(I)
=B(I)+C(I)
1 CONTINUE $1=3
Also:
DO 11 = 1, 10
A(I) = B(I) + C(I)
1 CONTINUE
1=3
COMMENT CARD
Comment information is designated by a C in col-
umn 1 of a statement. Comment information will
appear in the source program, but it is not trans-
lated into object code. Columns 2 through 80 may
be used. Continuation is not permitted; that is, each
line of comments must be preceded by the C
designator in column 1.
STATEMENT IDENTIFIERS
Any statement may have an identifier but only
statements referred to elsewhere in the program
require identifiers. A statement identifier is a string
of 1 to 5 digits occupying any column positions
1 through 5.
If I is an identifier, 1^1^ 99999; leading zeros are
ignored; 1, 01, 001, 0001 are equivalent forms.
Zero is not a statement identifier. In any given pro-
gram or subprogram each statement identifier must
be unique. If the statement identifier is followed
by a character other than blank in column 6, the
statement identifier is ignored.
Statement identifiers of Declarative statements (ex-
cepting FORMAT) are ignored by the compiler,
except for diagnostic purposes.
CONTINUATION
The first fine of every statement must have a blank
in column 6. If statements occupy more than one
fine, all subsequent lines must have a FORTRAN
character other than blank or zero in column 6. A
FORTRAN-66 statement may have up to 660 opera-
tors, delimiters (commas or parentheses) and identi-
fiers within it. The compiler will accept up to nine
continuation cards.
IDENTIFICATION FIELD
Columns 73 through 80 are always ignored in the
translation process. These columns, therefore, may
be used for identification when the program is to
be punched on cards. Usually these columns con-
tain sequencing information provided by the pro-
grammer.
PUNCHED CARDS
Each line of the coding form corresponds to one
80-column card; the terms line and card are often
used interchangeably. Source programs and data
A-l
can be read into the computer from cards; a relo-
catable binary deck or data, can be punched di-
rectly onto cards.
Blank cards appearing within the input card deck
are ignored.
When cards are being used for data input, all 80
columns may be used.
CARRIAGE CONTROL
When printing on-line, the first character of a rec-
ord transmitted by a PRINT statement is a carriage
control character for spacing on the printer. The
carriage control characters are:
Action
Single space after printing
Double space before printing
Eject page before printing
Suppress spacing after print-
ing, causing two successive
records to be printed on the
same line.
The characters, 1 -f, are not printed; any other
causes single spacing and is not printed.
When printing off-line, the printer control is deter-
mined by a printer routine for a particular installa-
tion.
Character
Blank or any
character other
than die follow-
ing
1
+
«
A-2
9
B. CENTRAL PROCESSOR
OPERATION CODES
•
»
Octal
Opcode
Mnemonic
Address
Comments
. BRANCH UNIT
00
PS
. Program stop
01
RJ
K
. Return jump to K
02
JP
Bi
+ K
. Jump to Bi + K
030
ZR
Xj
K
. Jump to K if Xj =
031
NZ
Xj
K
. Jump to K if Xj ^
032
PL
Xj
K
. Jump to K if Xj = plus (positive)
033
NG
Xj
K
. Jump to K if Xj = negative
034
IR
Xj
K
. Jump to K if Xj is in range
035
OR
Xj
K
. Jump to K if Xj is out of range
036
DF
Xj
K
. Jump to K if Xj is definite
037
ID
Xj
K
. Jump to K if Xj is indefinite
04
EQ
Bi
Bj K
. Jump to K if Bi = Bj
04
ZR
Bi
K
. Jump to K if Bi = B0
05
NE
Bi
Bj K
. Jump to K if Bi =£ Bj
05
NZ
Bi
K
. Jump to K if Bi ^ B0
06
GE
Bi
Bj K
. Jump to K if Bi ^ Bj
06
PL
Bi
K
. Jump to K if Bi ^ B0
07
LT
Bi
Bj K
. Jump to K if Bi < Bj
07
NG
Bi
K
. Jump to K if Bi < B0
. BOOLEAN UNIT
10
BXi
Xj
. Transmit Xj to Xi
11
BXi
Xj*
Xk
. Logical Product of Xj & Xk to Xi
12
BXi
Xj
+ Xk
. Logical sum of Xj & Xk to Xi
13
BXi
Xj
- Xk
. Logical difference of Xj & Xk to Xi
14
BXi
- :
Kk
. Transmit the comp. of Xk to Xi
15
BXi
-:
>Ck*Xj
. Logical product of Xj & Xk comp. to Xi
16
BXi
-:
5Ck + Xj
. Logical sum of Xj & Xk comp. to Xi
17
BXi
" :
Kk - Xj
. Logical difference of Xj & Xk comp. to Xi
. SHIFT UNIT
20
LXi
jk
. Left shift Xi, jk places
21
AXi
jk
. Arithmetic right shift Xi, jk places
22
LXi
Bj
Xk
. Left shift Xk nominally Bj places to Xi
23
AXi
Bj
Xk
. Arithmetic right shift Xk nominally Bj places to Xi
24
NXi
Bj
Xk
. Normalize Xk in Xi and Bj
25
ZXi
Bj
Xk
. Round and normalize Xk in Xi and Bj
26
UXi
Bj
Xk
. Unpack Xk to Xi and Bj
27
PXi
Bj
Xk
. Pack Xi from Xk and Bj
43
MXi
jk
. Form mask in Xi, jk bits
B-l
Octal
Opcode
Mnemonic
Address
Comments
. ADD UNIT
30
FXi
Xj + Xk
. Floating sum of Xj and Xk to Xi
31
FXi
Xj - Xk
. Floating difference Xj and Xk to Xi
32
DXi
Xj + Xk
. Floating DP sum of Xj and Xk to Xi
33
DXi
Xj - Xk
. Floating DP difference of Xj and Xk to Xi
34
RXi
Xj + Xk
. Round floating sum of Xj and Xk to Xi
35
RXi
Xj - Xk
. Round floating difference of Xj and Xk to Xi
. LONG ADD UNIT
36
IXi
Xj + Xk
. Integer sum of Xj and Xk to Xi
37
IXi
Xj - Xk
. Integer difference of Xj and Xk to Xi
. MULTIPLY UNIT
40
FXi
Xj * Xk
. Floating product of Xj and Xk to Xi
41
RXi
Xj * Xk
. Round floating product of Xj & Xk to Xi
42
DXi
Xj * Xk
. Floating DP product of Xj & Xk to Xi
. DIVIDE UNIT
44
FXi
Xj / Xk
. Floating divide Xj by Xk to Xi
45
RXi
Xj / Xk
. Round floating divide Xj by Xk to Xi
46
NO
. No operation
47
CXi
Xk
. Count the number of l's in Xk to Xi
. INCREMENT UNIT
50
SAi
Aj + K
. Set Ai to Aj + K
50
SAi
Aj - K
. Set Ai to Aj + comp. of K
51
SAi
Bj + K
. Set Ai to Bj + K
51
SAi
Bj - K
. Set Ai to Bj + comp. of K
52
SAi
Xj + K
. SetAitoXj + K
52
SAi
Xj - K
. Set Ai to Xj + comp. of K
53
SAi
Xj + Bk
. Set Ai to Xj + Bk
54
SAi
Aj + Bk
. Set Ai to Aj + Bk
55
SAi
Aj - Bk
. Set Ai to Aj — Bk
56
SAi
Bj + Bk
. Set Ai to Bj + Bk
57
SAi
Bj - Bk
. Set Ai to Bj - Bk
60
SBi
Aj + K
. Set Bi to Aj + K
60
SBi
Aj - K
. Set Bi to Aj + comp. of K
61
SBi
Bj + K
. Set Bi to Bj + K
61
SBi
Bj - K
. Set Bi to Bj + comp. of K
62
SBi
Xj + K
. Set Bi to Xj + K
62
SBi
Xj - K
. Set Bi to Xj + comp. of K
63
SBi
Xj + Bk
. Set Bi to Xj + Bk
64
SBi
Aj + Bk
. Set Bi to Aj + Bk
65
SBi
Aj - Bk
. Set Bi to Aj - Bk
66
SBi
Bj + Bk
. Set Bi to Bj + Bk
67
SBi
Bj - Bk
. Set Bi to Bj - Bk
•
1
B-2
t
Octal
Opcode
Mnemonic
70
SXi
70
SXi
71
SXi
71
SXi
72
SXi
72
SXi
73
SXi
74
SXi
75
SXi
76
SXi
77
SXi
Address
Comments
AJ + K
Aj -K
Bj +K
Bj -K
Xj +K
Xj -K
Xj +Bk
Aj + Bk
-Bk
+ Bk
Aj
Bj
Bj - Bk
Set Xi to A
Set Xi to A
Set Xi to B
SetXitoB
Set Xi to X
Set Xi to X;
Set Xi to X-
Set Xi to A
Set Xi to A
Set Xi to B
Set Xi to B
+
+ K
comp. of K
+ K
+ comp. of K
+ K
+ comp. of K
+ Bk
+ Bk
- Bk
+ Bk
- Bk
t
B-3
%
•
#
9
it
C. STATEMENTS OF FORTRAN-66
Subprogram Statements
Entry Points
Inter-subroutine
Transfer Statements
PROGRAM name
SUBROUTINE name
SUBROUTINE name (p x ,p 2) . . . )
FUNCTION name ( Pl ,p 2 , . . . )
REAL FUNCTION name ( Pl p 2 , . . . )
INTEGER FUNCTION name ( PlJ p 2j . . . )
DOUBLE PRECISION FUNCTION name ( Pl ,p,
COMPLEX FUNCTION name (p 1; p 2 , . . . )
LOGICAL FUNCTION name ( Pl ,p 2 , . . . )
ENTRY name
EXTERNAL name^name,, . . .
CALL name
CALL name (p 1; . . . ,p n )
RETURN
Data Declaration and Storage Allocation
Type Declaration
TYPE COMPLEX List
TYPE DOUBLE List
TYPE REAL List
TYPE INTEGER List
TYPE LOGICAL List
COMPLEX List
DOUBLE PRECISION List
REAL List
INTEGER LIST
LOGICAL List
DIMENSION V 1; V 2) . . .,V n
COMMON/I i /List
EQUIVALENCE (A,B, • ■ • ), (A1,B1, ...)■••
DATA (L = List), (L = List), . . .
BANK, (bj), name!, . . . , (b 2 ), name,, . . .
Arithmetic Statement Function
Function (pi.p^, • • • p.i) — Expression
Symbol Manipulation, Control and I/O
Storage Allocations
Replacement
A = E Arithmetic
L = E Logical/Relational
M = E Masking
A m = . . . = A x = E Multiple
N — Non-executable E — Executable
N*
N
N
N
N
N
N
N
N
N
N
E
E
E
N
N
N
N
N
N
N
N
N
N
N
N
N
N
N
E
E
E
E
C-l
Infra-program Transfers
GOTOn
GO TO m, (n, . . . n,„)
GO TO (n 1; . . . ,n m )i
GO TO (n 1: . . . ,n n ,),i
IF (A) n 1; n 2 ,n :l
IF (L) n x n 2
IF (L)s
IF (SENSE LIGHT i) ni ,n 2
IF (SENSE SWITCH i) ni ,n 2
IF DIVIDE
{
Loop Control
Miscellaneous Program Controls
FAULT }
CHECK/ ni ' n2
IF EXPONENT FAULT n l5 n 2
IF OVERFLOW FAULT n 1>n ,
IF (EOF,i) ni ,n 2
IF (IOCHECK), i) n x ,n 2
IF (UNIT,i) n^n^n*
IF (UNIT,i) n^n^n.,
IF (UNIT,i) n x ,n 2
DOn 1 =m 1 ,m 2 ,m 3
I/O Format
I/O Control Statements
I/O Tape Handling
Internal Data
Manipulation
ASSIGN s TO m
SENSE LIGHT i
CONTINUE
PAUSE; PAUSE n
STOP; STOP n
FORMAT (spec 1; spec,, . . . )
READ n,L
PRINT n,L
PUNCH n,L
READ (i,n) L
READ INPUT TAPE
WRITE (i,n) L
WRITE OUTPUT TAPE 1
READ (i) L \
READ TAPE i,L /
WRITE (i) L
WRITE TAPE i,L
BUFFER IN (i,p) (A : B)
BUFFER OUT (i,p) (A,B)
END FILE i
REWIND!
BACKSPACE i
ENCODE (c 3 n ; V) L
DECODE (c,n,V) L
i,n,L j
i,n,L j
Program and Subroutine Termination
END
C-2
E
E
E
E
E
E
E
E
N
E
E
E
E
E
E
E
E
E
E
E
E
E
E
N
E
E
E
E
E
E
E
E
E
E
E
E
n
♦
N/E
^
D. LIBRARY FUNCTIONS
It
Form
ABSF(X)
XABSF(i)
INTF(X)
XINTF(X)
MODF(X 1J X 2 )
XMODF (i x ,i 2 )
MAX0F(i 1; i2, . . .)
MAX1F(X 1I X 2 , . . .)
XMAX0F(i 1: i 2) . . .)
XMAXlF(X 1J X a , . . .)
MIN0F(i 1 ,i 2 , • • ■)
MIN1F(X 1 ,X 2J ...).
XMIN0F(i,i 3 , . . .)
XMIN1F(X 1; X 2 , . . .)
SINF(X)
COSF(X)
TANF(X)
ASINF(X)
ACOSF(X)
ATANF(X)
TANHF(X)
SQRTF(X)
LOGF(X)
EXPF(X)
SIGNF(X 1) X 2 )
XSIGNF(i 1; i 2 )
DIMF(X 1; X 2 )
XDIMF(i 1; i 2 )
Definition
Absolute Value
Truncation, integer
Xi modulo X 2
ii modulo i 2
> Determine maximum argument
1 Determine minimum argument
Sine X radians
Cosine X radians
Tangent X radians
Arcsine X radians
Arccos X radians
Arctangent X radians
Hyperbolic tangent X radians
Square root of X
Natural log of X
e to Xth power
Sign of X 2 times |Xi I
Sign of i 2 times lij
fIFX 1 >X 2 :X 1 -X 2
flf ii>i 2 : ii-i 2
llfi^i,:
Actual Param-
Mode of
eter Type
Result
Real
Real
Integer
Integer
Real
Real
Real
Integer
Real
Real
Integer
Integer
Integer
Real
Real
Real
Integer
Integer
Real
Integer
Integer
Real
Real
Real
Integer
Integer
Real
Integer
Real
Real
Real
Real
Real
Real
Real
Real
Real
Real
Real
Real
Real
Real
Real
Real
Real
Real
Real
Real
Real
Real
Integer
Integer
Real
Integer
Real
Integer
D-l
Actual Param-
Mode of
Form
Definition
Cube root of X
eter Type
Real
Result
CUBERTF(X)
Real
FLOATF(I)
Integer to Real Conversion
Integer
Real
RANF(N)*
Generate Random Number
-Real |
— Integer (
Real
(Repeated Executions give uniformly
distributed numbers)
+ Real \
+ Integer |
Integer
XFIXF
Real to Integer Conversion
Real
Integer
POWER(X 1 X 2 )
X^ 2
Real, Real
Real
ITOJ(IJ)
F
Integer, Integer
Integer
XTOI(X,I)
X 1
Real, Integer
Real
ITOX(I,X)
F
Integer, Real
Real
LENGTHF(i)
Number of words read on unit i
Integer
Integer
*Any compiled calls to RANF(N), used as a func-
tion, treat the resulting value as real.
D-2
w_
i
E. QUANTITIES AND WORD STRUCTURE
FORTRAN-66 manipulates floating point and inte-
ger quantities. Floating point quantities have an
exponent and a fractional part. The following classes
of numbers are floating point quantities.
REAL
Exponent and sign 11 bits; fraction and sign 49
bits; range of number, (in magnitude) 10- 308 ^N^
10 308 and zero; precision approximately 14Vi deci-
mal digits.
DOUBLE
Each half is independendy packed.
COMPLEX
Two reals as defined above.
Integer quantities do not have a fractional part.
The following classes of numbers are integer quan-
tities:
INTEGER
Represented by 60 bits, first bit is the sign; range
of number (in magnitude) O^N— 2 00 — 1; precision
is up to nVz decimal digits.
LOGICAL
1 bit represents the value TRUE.
bit represents the value FALSE.
HOLLERITH
Binary coded decimal (BCD) representation treated
as an integer number.
A FORTRAN-66 program may contain any or all of
these classes of numbers in the forms of constants,
variables, elements of arrays, evaluated functions
and so forth. Variables, arrays and functions are
associated with types assigned by the programmer.
The type of a constant is determined by its form.
•
WORD STRUCTURE
The word structure of the quantities in FORTRAN-
66 is shown below:
FLOATING POINT QUANTITIES
SIGNS
2 10
48
SIGNS
EXP
FRACT.
SIGNS
48
REAL
2 10
48
REAL
COMPLEX
SIGNS
SIGNS
IMAGINARY
2 10
48
2 10
48
DOUBLE
MOST SIGNIFICANT
INTEGER QUANTITIES
LEAST SIGNIFICANT
59
-SIGN
^UNUSED %31|
6 6 6 6 6 6 6 6 6 6
INTEGER
LOGICAL
HOLLERITH
TYPE
REMARKS
COMPLEX
DOUBLE
REAL
INTEGER
HOLLERITH
LOGICAL
2 WORDS
2 WORDS
1 WORD
1 WORD
1 WORD
1 BIT
CONSECUTIVE MEMORY LOCATIONS
CONSECUTIVE MEMORY LOCATIONS
6 BITS/CHARACTER
•ELEMENT LENGTH
E-l
<fe
•
•
#
F. PROGRAM SEGMENTATION
•
'®
In general, the complex for a central processor pro-
gram is assumed to be made up of control programs,
subroutines, and common data blocks. The initiating
control program, any common subroutines and data
blocks comprise a permanent segment in core. Any
subsequent control programs, subroutines and then-
data blocks are arranged dynamically in core in seg-
ments according to requests encountered during
execution, and as defined by segmentation control
cards.
The compiling process handles all programs and
subroutines individually. The routines are compiled
separately and, in binary form, are put together
with segmentation specifications at execute time.
Linkage betwen segments and between routines is
handled at load time. Although a routine may ap-
pear in any number of segments, only one copy need
be compiled and placed with the job.
Definition of Terms
Basic Segment — a fixed arrangement of a con-
trol program, subroutines, and common data
blocks.
Normal Segment — an arrangement of a control
program, subroutines, and common data read
into central memory dynamically as required.
It is defined by a segment control card and
loaded by means of the LOAD statement. Nor-
mal segments may be overlayed.
Control Program — defined with a PROGRAM
card and is the only executable program widiin
a basic segment or a normal segment.
Subroutine — a routine defined by a SUB-
ROUTINE card and executed by means of a
CALL statement.
LOAD — is a macro defined as the overlay
segment request.
The contents of a segment are provided by seg-
mentation control cards at load time and are speci-
fied as a combination of control programs, sub-
routines, and other segments. The overlay operation
when executed does not disturb die contents of the
basic segment. However, it does destroy all other
requested segments operated prior to the loading of
the overlay. Overlay requests may occur without
restriction in any segment and are coded in line
where the decision is reached that an overlay is
required.
Two independent segmentation concepts are pro-
vided under a single programming mechanism. The
first method allows a basic segment, which resides
permanently, in core, to initiate loading, and to con-
trol routing to the various subroutines in the job.
Under this concept, control flows back and forth
between the basic segment and any routine in the
other segments, but always returns to the basic
segment prior to the initiation of an overlay. When
an overlay is initiated, control continues to the next
instruction in line (no control transfer occurs).
The second method provides a program chaining
operation. Under this method each successive over-
lay has its own control program and provides con-
trol routing dirough the various routines in that
overlay. Each new overlay destroys the preceding
one. Since loading is initiated by the overlay, it is
necessary that a control transfer be made in con-
junction with the load request.
An overlay request may occur in any segment. How-
ever, a transfer address must be provided if the
request is made from other than the basic segment.
The transfer address, if required, is taken to be that
of the control program which has a trace of asterisks
all the way through to the LOAD statement. An
example of a segmented program and the tracing
of control through the segments with asterisks
follows :
EXAMPLE: (Control in Normal Segments)
Assume the basic segment is loaded consisting
of non-executable statements defining common
data and storage areas and a load request:
LOAD * SEG1 *
SEG1 is defined as:
SEG1 = ^PROGRAM A*, SUBROUTINE
Al, SUBROUTINE A2
After die load is accomplished, control is
shifted to Program A as a result of asterisks
around SEG1 and Program A in die definition
of SEG1.
F-l
Assume a load request is given in SEG1:
LOAD * SEG2 *
SEG2 = *PROGRAM B*, SUBROUTINE
Bl, SUBROUTINE B2
The load is then performed and control turned
over to Program B.
Suppose an overlay request exists within SEG2
which includes both segments SEG1 and SEG2,
plus Program C. In addition, suppose control
is to be shifted back to Program A after SEG3.
has been loaded. The specification of the third
segment may take one of several forms:
1. SEG3 = *PROGRAM A*, SUB-
ROUTINE Al, SUB-
ROUTINEA2, PROGRAM B,
SUBROUTINE Bl,
SUBROUTINE B2,
PROGRAM C
2. SEG3 = /*SEG1V, PROGRAM B,
SUBROUTINE Bl,
SUBROUTINE B2,
PROGRAM C
3. SEG3 = /*SEG1V, /SEG2/,
PROGRAM C
where slashes indicate the enclosed is a
segment name.
Upon a LOAD *SEG3* statement, each of
these three forms will produce the same core
arrangement and transfer control to Program A
since it is the only routine in this segment
specification which has an asterisk trace through
the segment definitions to the LOAD statement.
Program A is asterisked (definition 1 above
contains asterisks around Program A, defini-
tions 2 and 3 above have asterisks around
SEG1, which contains Program A enclosed
with asterisks), SEG3 is asterisked in the LOAD
statement.
However, if control is desired for Program C,
SEG3 may then be defined as :
SEG3 = /SEG1/, /SEG2/,
♦PROGRAM C*
or either of the other two forms may be used
with Program C enclosed with the asterisks.
A transfer address is not necessary when the basic
segment maintains control throughout the execution
of the object program. In this instance, segments
consist of subroutines which are executed by means
of a CALL statement. An example of a segmented
program with control residing in the basic segment
follows:
EXAMPLE: (Control in Basic Segment)
Assume the basic segment is loaded and execut-
ing. At some point within the basic segment, a
load request is coded:
LOAD SEG4
SEG4 is defined as:
SEG4 = SUBROUTINE A,
SUBROUTINE Al,
SUBROUTINE A2
After the load is accomplished, all program-
ming conventions relative to subroutine calls
and communications may be followed. How-
ever, when the tasks of the routines in the
normal segment are completed, control always
reverts to the calling program in the basic seg-
ment which may then request the loading of
another segment.
With reference to these examples, general charac-
teristics of segment specifications are stated as
follows :
1. Segments may be defined as a combination of
routines and other segments. There is no limit
on the depth used in the specification. Segment
hierarchies may be conveniently defined as speci-
fying large and highly overlapping segments.
2. There is no requirement that a one-to-one cor-
respondence exist between segment definitions
and segments referenced in LOAD statements.
Extra segments may be defined which contain
common groupings of routines and these seg-
ments may then be used to define the larger
segments. Each segment referenced by a LOAD
statement must be defined by a segmentation
card; if not, the entire job is aborted.
3. With the chaining method, control is passed to a
program in the loaded segment by an unbroken
chain of asterisks from the LOAD statement
through the segment specifications to the pro-
gram name. This provides the necessary control
routine capability.
F-2
4. There is no requirement that program or sub-
routine names appear uniquely in the combina-
tion of segments that define a segment. The
union of the segments designates the routines to
be loaded. This assures that there is no loss in
core utilization due to name redundancies.
5. Segment identifiers used in the definition of other
segments are surrounded by slash marks (/) to
distinguish them from program and subroutine
names. If a segment name is enclosed in asterisks,
the asterisks are placed inside the slash marks.
The following restrictions are made:
1. If the LOAD statement specifies a transfer of
control, one and only one program in the loaded
segment must be designated as recipient of the
control by meeting characteristic number 3.
2. No mixing of the two methods is permissible
although a one-time switch may be made from
the basic segment concept to the chaining con-
cept. Once the chaining process is used, there is
no way to return control to the PROGRAM in
the basic segment.
A core map taken at the completion of the loading
of the basic segment would show the control pro-
grams, the programmer subroutines in the basic
segment, one copy of common data blocks, and one
copy of library subroutines and functions referenced
by these basic segment routines. The block of
memory required for this segment is permanently
reserved. The next location after this block is the
initial address for all normal segments called by a
LOAD statement.
If there are additional segments specified to ac-
company the basic segment in the initial load or
when an overlay request occurs, these segments are
brought in from the disk and relocated at the initial
overlay address. Addresses for common blocks refer-
enced in the segments are determined from their
location within the basic segment, or they are as-
signed and inserted where appropriate. Also one
copy of any library subroutine, not previously
required or loaded, is added to the program and
linkages for all routines are then made.
When a transfer is indicated by the segment speci-
fication (asterisks around NAME), a similar name
form is sought from the segment name list and
control is routed to its single entry point.
F-3
#
#
•
#
•
G. FORTRAN ERROR PRINTOUTS
Listed below are the diagnostic error printouts currently available with FORTRAN-66. A one (1) before the
statement indicates that no further compilation takes place. However, the subsequent FORTRAN statements
are diagnosed for errors. A zero (0) before the statement indicates that the program will be compiled, but
execution is likely to be subject to error.
I""" 8 " UNRECOGNIZABLE STATEMENT
l'FUNCTION STATEMENT FORMAT ERROR
l a SUBROUTINE STATEMENT FORMAT ERROR
1"" "SUBROUTINE OR VARIABLE NAME TOO LONG
l"MORE THAN 20 ENTRIES
l"°ERROR IN CALL STATEMENT** 00
1° "ILLEGAL CHARACTER
l°°MORE THAN 63 PARAMETERS IN LIST 0000
1° DUPLICATION IN PARAMETER LIST 000
0°"NO HEADER CARD FOUND ASSUME FORTRAN MODE 00
l°°MORE THAN ONE HEADER CARD 00
1° DECLARATIVE STATEMENT OUT OF ORDER 000
0* 'NON-EXECUTABLE PROGRAM 00000
l"MORE THAN 9 CONTINUATIONS
1 RETURN STATEMENT USED IN PROGRAM MODE
l 000000 'UNCLOSED DO LOOP DO [N] I = ETC. 000000
1°°DUPLICATE ENTRY NAME 00
1° DIMENSION NOT FOUND, VARIABLE 00000000
l°DIMENSION EXCEEDED, VARIABLE 00000000
1°SUBSCRIPT NOT FOUND, VARIABLE 00000000
1 000000 ARITHMETIC STATEMENT FORMAT ERROR
l°NO EQUAL SIGN FOUND IN ARITHMETIC STATEMENT
1"LEFT SIDE ERROR
1 "ELEMENT NOT AN ARRAY
l°FUNCTION NOT ON LEFT
1""" "ILLEGAL ALPHA-CHARACTER APPEARING IN NUMBER FIELD
1 "ILLEGAL PERIOD (.) OCCURRING
1 000 "*°"UNBALANCED PARENTHESIS
1"°»«ILLEGAL CHARACTER IN OCTAL NUMBER FIELD
1" ""ERROR IN GO TO STATEMENT""
1 "ASSIGN STATEMENT FORMAT ERROR
1""IF STATEMENT FORMAT ERROR
l"ERROR IN SENSE LIGHT STATEMENT"
l 0000 ERROR IN DO STATEMENT
1"" "INDEX USED BY ANOTHER DO
l'DO STATEMENT ENDED BY •«•»«•«», ILLEGALLY NESTED ""
l"*DO STATEMENT NEXT CONTAINS MORE THAN 50 oooo °
0°DO STATEMENT ENDED BY A TRANSFER STATEMENT
1" "ERROR IN I/O STATEMENT"" ""
1ARRAY XXXX IS NOT A SUBROUTINE FORMAL PARAMETER
1SUBSCRIPT XXXX IS NOT A SUBROUTINE FORMAL PARAMETER
1COMMON/EQUIVALENCE CONFLICT, VARIABLES . . . XXXX AND . . . YYYY
1LITERAL TABLE OVERFLOW
lOCTAL TO DISPLAY CONVERSION ERROR
G-l
1EQUIVALENCE STATEMENT REFERENCE CONFLICT, VARIABLE XXXX REFERENCES c
VARIABLE YYYY IN MORE THAN ONE WAY. FIRST REFERENCE PREVAILS ™
1EQUIVALENCE STATEMENT REFERENCE CONFLICT, VARIABLE XXXX REFERENCES ITSELF
1FORMAL PARAMETER XXXX APPEARS IN A COMMON STATEMENT
OOBSERVE EQUIVALENCE STATEMENT SUBSCRIPT RULES
1FORMAT ERROR
OCOMMA AT END OF STATEMENT
1TYPE STATEMENT CONFLICT, VARIABLE XXXX
ODUPLICATE TYPE STAEMENT, VARIABLE XXXX
UNCOMPLETE STATEMENT
1TOO MANY SUBSCRIPTS, VARIABLE XXXX
1COMMON STATEMENT CONFLICT, VARIABLE XXXX
1PRIOR SUBSCRIPTS WILL BE USED
1DIMENSION STATEMENT CONFLICT, VARIABLE XXXX
1COMMON STATEMENT/DIMENSION STATEMENT CONFLICT, VARIABLE XXXX
ODIMENSION STATEMENT SUBSCRIPTS WILL BE USED
ODUPLICATE SUBSCRIPT SET ASSIGNED TO VARIABLE XXXX
1SUBSCRIPT, VARIABLE XXXX IS TOO BIG
1SUBSCRIPT CONFLICT OR DUPLICATE, VARIABLE XXXX
1FORMAL PARAMETER XXXX APPEARS IN AN EQUIVALENCE STATEMENT
OA MINIMUM OF TWO VARIABLES MUST OCCUR IN EACH EQUIVALENCE GROUP
1FUNCTION CALLING SEQUENCE ERROR. FUNCTION XXXXX
1LEFT SIDE NOT TYPE LOGICAL, WITH RIGHT SIDE RELATIONALS.
1FAILURE OF E Q B6 B7 K , TO JUMP ON EQUALITY.
1STATEMENT FUNCTION TABLE FULL.
1NUMBER OF PARAMETERS DOES NOT AGREE WITH STATEMENT FUNCTION DEFINITION A
IUNIARY SIGN FORMAT ERROR. W
1RIGHT SIDE RESULTS MASSING. $$$$$$$$$$$$$$$$$$$$$$$
1MULTIPLE RIGHT SIDE RESULTS. $$$$$$$$$$$$$$$$$$$$$$
1UNKNOWN ELEMENT AS AN OPERAND = $$$$$$$$$$$$$$ XXXXX
1ARITHMETIC OPERANDS ARE NOT SAME TYPE. !$$$$$$$
10PERANDS HAVE ILLEGAL TYPE 6. $$$$$$$$$$$$$$$$$$$$$
IOPERANDS HAVE ILLEGAL TYPE 7. $$$$$$$$$$$$$$$$$$$$$
HLLEGAL TYPE 6, FOR CONVERSION. $$$$$$$$$$$$$$$$$$$
HLLEGAL TYPE 7, FOR CONVERSION. $$$$$$$$$$$$$$$$$$$$
HLLEGAL TYPE 6, FOR CONVERSION. TO OCTAL. $$$$$$$$$
HLLEGAL TYPE 7, FOR CONVERSION. TO OCTAL. $$$$$$$$$
HLLEGAL TYPE 6, FOR CONVERSION. TO LOGICAL. $$$$$$
HLLEGAL TYPE 7, FOR CONVERSION. TO LOGICAL. $$$$$$
HLLEGAL TYPE 6, FOR CONVERSION. TO INTEGER. $$$$$$
HLLEGAL TYPE 7, FOR CONVERSION. TO INTEGER. $$$$$$
HLLEGAL TYPE 6, FOR CONVERSION. TO REAL. $$$$$$$$$$$
HLLEGAL TYPE 7, FOR CONVERSION. TO REAL. $$$$$$$$$$$
HLLEGAL TYPE 6, FOR CONVERSION. TO DOUBLE. $$$$$$$
HLLEGAL TYPE 7, FOR CONVERSION. TO DOUBLE. $$$$$$$
HLLEGAL TYPE 6, FOR CONVERSION. TO COMPLEX. $$$$$
HLLEGAL TYPE 7, FOR CONVERSION. TO COMPLEX. $$$$$
1DUPLICATE STATEMENT FUNCTION = XXXXX
OZERO SUBSCRIPT CHANGED TO ONE FOR VARIABLE XXXXX
G-2
^P*'
o
o
u
CONTROL DATA SALES OFFICES
ALAMOGORDO • ALBUQUERQUE • ATLANTA • BILLINGS • BOSTON • CAPE
CANAVERAL • CHICAGO • CINCINNATI • CLEVELAND • COLORADO SPRINGS
DALLAS • DAYTON . DENVER • DETROIT • DOWNEY, CALIFORNIA • HONOLULU
HOUSTON • HUNTSVILLE • ITHACA . KANSAS CITY, KANSAS . LOS ANGELES
MADISON, WISCONSIN • MINNEAPOLIS • NEWARK • NEW ORLEANS • NEW
YORK CITY • OAKLAND • OMAHA • PALO ALTO • PHILADELPHIA • PHOENIX
PITTSBURGH • SACRAMENTO • SALT LAKE CITY • SAN BERNARDINO • SAN
DIEGO • SEATTLE . ST. LOUIS . WASHINGTON, D.C.
ATHENS • CANBERRA ■ DUSSELDORF . FRANKFURT . THE HAGUE • HAMBURG
JOHANNESBURG • LONDON • MELBOURNE ■ MEXICO CITY (REGAL ELEC-
TRONICADE MEXICO, S.A.)- MILAN • MONTREAL • MUNICH • OSLO . OTTAWA
PARIS • SAVYON • STOCKHOLM • STUTTGART • SYDNEY • TOKYO (C.ITOH
ELECTRONIC COMPUTING SERVICE CO., LTD.) • TORONTO • ZURICH
8100 34th AVE. SO., MINNEAPOLIS, MINN. 55440
CONTROL Dr ,
CORPORATION
© 1965, Control Data Corporation
Pub. No. 60101500 B
Litho in U.S.A.
