Digital PDFs

XX-54FAE-0F

1966

93 pages

Original

2.8MB

Document:	PDP-7 FortranII
Order Number:	XX-54FAE-0F
Revision:
Pages:	93
Original Filename:	http://bitsavers.org/pdf/dec/pdp7/PDP-7_FortranII.pdf

OCR Text

DIGITAL -7-2-S

OIOIT ...... I!:QUIPMENT CORPOR",TION

•

M ... VN ... "'O , ""' ... S .... C .... USETTS

DIGITAL -7-2-S

PDP-7 FORTRAN II
PROGRAMMING MANUAL

DIGITAL EQUIPMENT CORPORATION

•

MAYNARD, MASSACHUSETTS

CONTENTS
SECTION 1
PDP-7 FORTRAN II
Chapter
INTRODUCTION TO THE FORTRAN II LANGUAGE ..........•..•..•.••.•.
Introduction ....•.•••••••..•.•••.•...••.••••.......••.•...•..•.••.

FORTRAN II Language ••••.••.•.•...•.•.•..•....•.••.•.•..•.•...•••

Preparing the FORTRAN Program ••.•.•.••.••.•.••...••..••..•.••

Required Statements •••.••••.•..•.•..•..•.••...•..•.••.•••..•..

FORTRAN II Words.. • • • . • • • • . • . • • . • . . • . • • . . . . • . • . . • . • . . • • . • . • .

ARITHMETIC AND DATA-SPECIFICATION STATEMENTS .•..•..•.••.•.....•

Arithmetic Expressions ••.•..•.•.•.•...•.••.•.•..•.•..•.......•••...

Evaluation of an Expression...... . .•. .••. .. •• .• .• .• . .• ..• • . .•. .•

Use of Parantheses • • . . • • . . . . • . . . . . . . • . . • • . . . . . . . . . • . . . . • • . • • • . •

The Replacement (Equals) Sign..................................

Internal Arithmetic Statement.. .• .•• .• .•• .. . .. . •. . . .• . .• . •• .•.•.

Mode of Computation .•....••.•.••..•••.•....•........•....••.•

Data-Specification Statements......................................

Dimension Statements .....•...•.•.•..•.•....•••.....•....•..•.•

Floating-Point Storage Specifications .•.•.••.•............•..•.•.

PROGRAM CONTROL ••••.........•.•..•......•.•.....•..•.•..•••.....

Branches and Loops •......•.••.•....••.••••.•.•..•....•..•.••••••..

Unconditional GOTO Statements. • • . . . . . • • . • • . • . . . . • . • • . . . • • . • . .

DO Loops.... ...••. ..••.••. .. .. .• .. . .. ...... .• ..... ..•.. ... ..

The CONTINUE Statement .•.....•••.•....••.•.••.•....•...••..

Computed GOTO .••...•...••.•..•.••...•.......•....•.•..•.••

Assi gned GOTO .•..••.•..•......•..•..•.••......•.•....•...•.

Program Termination ...••••...••........•.....•....•.......•....•.•

The STOP Statement. • • . . . . . . • . . . . . • . . • . • . . . . • . . . . . . . . . . . . . . . . .

The PAUSE Statement.. .. . . . . .• . . . . . . . ... . •. .. .. . .. . . .. . ... .. . .

iii

CONTENTS (continued)
0

Page

Chapter

INPUT/OUTPUT STATEMENTS
Input/Output Assignments •.••..•...••.•••••.
The I/O Data List o.

••

I/O Specification Statements

•

000

•

000

•••

•

000.

,.0

000

•

000

••

•••

•

••

••••••

000.

•

...

000

••••••

Data Fie Ids .........................•.......•
Data Fie Id Formats •

The Format Statement

••

Format Speci fi cattons •••
Input/Output Devices ..•
Data Organ izati on .

•••

••

••••

•

••••••

•

000

•

••

•

••

•

00.0.00

••

•

••

•

000

•

•••••

•

•••••

••

0 0 . 0 0 . 0 0 0 0 0 . 0 0 0 0 0 0 ..

•••

00."

0.00000

••

000

•

••

•

I/o Operations with Magnetic Tape •

••

••••

•

000".00

••

00.

••

•

000

•••

•

••

0.0

Functi ons .•..•..•.••.•.•••..••••••••••••••.••.•.

••••••••••••••••

SUBPROGRAMS: FUNCTIONS AND SUBROUTINES.

The FUNCTION Definition Statement •.
RETURN Statements

000

••

000000.

•

••

Use of Functions .•...•........•....•.•..•..•.

•

Subrou ti nes

•

000

••

000

••

00.

•••

••••••

••

•

•••••

•••

• • •'

000

•

0000.00

••

•

Library Functions.

0000

I/O Operation with DECtape ."

•

.00

•

• • •'

•

••

•

••

000

•

000

•

00.000000

0.'

•••••••

.0.'

.•••••••..••.•••••.••••••••••.••••.••

The CALL Statement .
Common Storage

•

o ••

•

000

•

0.000000

00'

•

Array Names Used in Subroutines

••

Machine Language Coding in a FORTRAN Context o . ~
Handling of S Coding ••••.••
Compi ler Generated Coding
Subprogram Linking •.

••

••••

0.'

o.
0

0.0

000

•••

•••••••••

000

o.
O.

Construction of Dimensioned Variables ..•

••

••••

•

•••

000

•••••

•••

• • •'

•

00.

•

••

.0"

•••

•

•••

•

••••

•••••••

•

.00

••••

Allocation of Array Storage and the Subscript Calculator
I/O Statements

••

• • •'

••

•

I/O Operations with Paper Tape and Keyboard

o ••

000.00"

•

••••

•

28
28

29
30

35
35
38

39
41

43
43
43
44
44

45
46

46
47

48
49
49

50
52

57
57
58

CONTENTS (continued)
SECTION 2
OPERATING PROCEDURES, DIAGNOSTICS,
AND ERROR MESSAGES
Chapter

Page
OPERATING PROCEDURES •......•••••.•.•••........•....•........•....

Procedure for Using FORTRAN with a PDP-7 Paper Tape System ..•.......

DIAGNOSTICS .••.•.••.••.•....•.•.....•......•..•.•...••..........•.

ERROR MESSAGES (FORTRAN ASSEMBLER) .••.•.•.•.............•....•.•.

CHARACTER CODE EQUiVALENCES.....................................

USE OF EXTENDED MEMORY .••.••.•.•..•••..•..•...••.•..........•••.

FORTRAN SUMMARY DESCRIPTION .................................... .

Character Set (ASCII) . . . • • . . • . . • . • . . • . • . • • . . . . . . . . . • . . . . . . . . . . . . . . .

Punched Paper Tape Conventions .•...••.................•..•....•••.

Lega I Elements in Fie Id One ..•.•....•.•..•.•...•...••.....•..•.

Fie Id Two ••••••..•••..•.••.•.....••••.•.••.•.•..•..•.••.•.•.•

Number Representation. . • . • • . • . • . . • • • • . • . . • . • • • • • • • . . . . . . • . . . . • • . . .

Library Functi ons . • . • . • • . • . . • . • • • • . • • • . . • • . • . • • . • . • • . • . . • • • . . . . • . . .

FOR TRAN Statements ..••.••....•..•....•.•....•.....•.•....•....•.

Arithmeti c Statements (V = E) .•.••.•••.••..•.••.................

Control Statements .••••..•..•.••.•••••.••...•..•••..•.........

Appendix

ILLUSTRATIONS
Figure
1

A FORTRAN Program .••..•.................•......•..•................

Program Section with Comments ..•......................................

Example of the Continuation Character .•.........•.......................

ILLUSTRATIONS (continued)
Figure

Page

Example of a FORTRAN Program ••••.•.••.••.•.••••.••••..••...•••••••••••

Number Representation, Floating Point .•••••••.•..••••••..••••••••.•••.•••

Example of Subscripts •••.••.•••..•.•••.••••••.••••••••..•.••••.••••.••••

Arithmetic Statement

Examples of Ari thmeti c Expressions •••••••.•••.•••••••••...•.••••.••.•.••••

Schematic Representation of Program Branches ••••••.•.•••..•••••.••••••••••

Integer Summation ..••......•.......•.......••.••••.•.

••••••••••••••••

Use of IF Statement in Integer Summation Problem •••••••.•., ••.•.••.•.•..••.

Fibonacci Series ..•.......•.•....•..•........•••.••..

Fibonacci Series Calculation Programmed as a DO Loop •••..' ••.••..•.•••••••

Initialization of Array Storage •••••••.••••.•••••••.••••.' •••••••••.••••.•

DO Loops .•..•.•...•....•......•.•.•...•.•...••..•.•

••••••••••••••••

Program Branching in DO Loops .••.•..••.••••••.•••••••..•••••.•••••.•.••

I/O Statement .•••••..••••••.••••••••••••••••••••.•••

FORMA T Statements ..................................

Function Subprogram ••.•.••.•.•..•....•..•..•.••••••.•

Example of Factorial Calculator •••••••••••.•••••••.••••.' •••••••.•••••••.

44
47

Matrix Multiplication Subroutine •••••.•.••••••••••••••• " •••••••••••••••.

fl'

•••••••••••••••

••••••••••••••••

TABLES
Table
Summary of Format Specification Letters ••••••••••••••••• " •.••.••••••.••••

Definition of a Physical Record for I/O Devices .••••••••• " .•.•.••.••.••.••

I nput Format ••.•.•••..•.•.•••.•.•••••••. '.............................. .

Output Format .••....•••.•••••.•.••••.••.••.•..•.••••

••••••••••••••••

Core Representations of the ASCII Characters, A and H Formats .•.•..••••.••

SECTION 1

PDP-7 FORTRAN II

CHAPTER 1
INTRODUCTION TO THE

FORTRAN

LANGUAGE

I NTRODUCTI ON
FORTRAN II, like all compilers, relieves the programmer from exercising a detailed knowledge of the
computer language.

It is problem oriented and thus accepts input closely related to the problem and con-

verts this input into an executable machine language program.

For scientists and engineers, the PDP-7

FORTRAN II system provides, in easi Iy understood form, the means for writing PDP-7 FORTRAN II programs.
The compiler accepts input in the form of statements which resemble mathematical formulas, and compiles
the sequences of instructions needed to perform the procedures specified. Using this system, the programmer is able to concentrate on the problem rather than on detai led computer codes.
The PDP-7 FORTRAN II compi ler can compi Ie and run FORTRAN II programs written for other computers
provided that reasonable restrictions (such as sufficient memory capacity, use of acceptable terms and
expressions, and availabi lity of required peripheral equipment) are met.

Included in the PDP-7 FOR-

TRAN II system is a compiler, assembler, operating system, and subroutine library. Each of these subsections is described in later chapters. This manual is intended as a reference manual and assumes that
the reader is familiar with the general principles of FORTRAN II programming.

FORTRAN II LANGUAGE
PDP-7 FORTRAN II is composed of symbols which combine to form words or are used as punctuation, and
grouped into statements. These statements may be classified as follows:
1. Arithmetic Statements resemble algebraic formulas. They specify the mathemati ca I operati ons to be performed.
2. Program Control Statements direct the sequence of operations of the program.

3. Specification Statements allocate data storage, determine variable and data
types, and specify input/output formats.
4. Input/Output Statements control the transfer of information into and out of
the computer.

The rules of FORTRAN are somewhat stylized to permit ease in interpretation by the computer, as shown
in Figure 1 •

C
5
10

30
32

FACTORIAL PROGRAM
TH IS PROGRAM CALCULATES IX FACTORIAL FOR GIVE N IX
VVRITE 2, 100
READ 1, 200, IX
IFACT = IY = 1
IF (IX) 5,32,30
IF (lX-IY) 41, 32, 33
WRITE 2, 300, IX, IFACT

GO TO 10
33
IFACT = IFACT * (lY = IY + 1)
GO TO 30
41
PAUSE 7777
GO TO 5
100 FORMAT (/30H PLEASE TYPE A POSITIVE NUMBER/)
200 FORMAT (14)
300 FORMAT (/14, 13H FACTORIAL IS, 17/)
, END
Figure 1

A FORTRAN Program

Symbols which are meaningful to FORTRAN include letters, numbers, and v(lrious special characters.
The complete set is listed in Appendix 3 .

Since FORTRAN ignores spaces, t'hey may be used freely (ex-

cept for two restrictions which wi II be noted in the text) to make a program Imore readable.

Preparing the FORTRAN Program
Each line of a FORTRAN program contains two fields as shown in Figure 2:

the first is an identification

field; the second, the statement proper.

The Identification Field - This field extends from the left-hand margin to the first tabulation, and may be
left blank. If not, it may contain in the leftmost position one of the following types of identification:
1. The first' digit of a statement number, which may be any integer from 1 to 99999,
inc lusive, identi fying the statement on that Iine for reference by other parts of the
program.

Statement numbers are used for program control or to assi st the programmer

in identifying segments of his program.
2.

The letter C which identifies the remainder of the line as a comment.

Although

a FORTRAN program, using English words and mathematical symbols, can be read
and understood more easily than a symbolic language program, comments throughout

the program explain the procedures being used. Such comments, identified by a
C in the first position of the identification field, are not interpreted by the compiler and have no effect on the executable program. Figure 2 is a section of a
program wi th comments.
C
C

CALCULATE PERCEN"):AGE OF CORRECT RESPONSES
PERCENTAGE = -1 IF THERE ARE NO ITEMS IN CATEGORY
DO 47 I = 1, 57
DO 48 J = 1, 6
IF (ITEMS (I, J)) 46, 46, 49
PERCEN (I, J) = -1.0

Figure 2

Program Section with Comments

3. The letter S, which identifies the remainder of the line as symbolic machine
instructions.
4. The continuation character ($), which identifies the statement as a continuation of
the preceding statement. Frequently a statement may be too long to fit on one line
(this is especially true of format statements).

If the character ($) begins the identi-

fication field of a line, the statement field of that line is treated as a continuation
of a statement on the line above. A statement may be continued on as many lines as
necessary to complete it, but the maximum number of characters in the statement may
not exceed 300 (approximately 4-1/2 lines). Figure 3 is an example of the continuation character.
3

$
Figure 3

X=X+(ARG1+2.* ARG2+2. *ARG3+
ARG4)/6
Example of the Continuation Character

The Statement Field - This field begins immediately after the first tabulation and extends through the next
carriage return. Thus, no more than one statement can be written on one line, but a single statement can
extend over one line using the continuation character. (See above.)

Required Statements
Figure 4 is an example of a FORTRAN program, consisting of the title, the body of the program, and the
END statement.

SUMMATION OF FIRST 50 INTEGERS
SET ITOTAL = 0 BEFORE SUMMING
ITOTAL == 0
DO 3 I = 1, 50
ITOTAL == ITOTAL +1
END

Figure 4

Example of a FORTRAN Program

The first line of the program is the title, which may be anything the programmer wishes to write to identify
his program. The title is not incorporated into the final executable program. Note that although a title
is necessary, it need not be preceded by a C.
The body of the program is a series of statements, each of which specifies a sequence of mathematical
operations, controls the flow of the program, or performs other tasks related j"O the proper working of the
program.
The END statement is a required statement and must be the last statement of every FORTRAN program. Its
function is to indicate to the compiler that nothing more connected with the preceding program is to
follow.

FORTRAN II Words
Words fall into three categories: numbers, variables, and commands. Numbers and variables are determined by the programmer and dealt with here, and commands are discussed in succeeding chapters.

Number Representati on
In mathematics, there are many ways to categorize numbers. They may be positive or negative, rational
Qr imaginary, whole numbers or fractions. In PDP-7 FORTRAN II, the treatment of numbers is separated
into integers and real numbers (single decimals or numbers in decimal exponent form), distinguished as
follows:
Integers are constants which are written without a decimal point. Typical integers are: 9, 17, -8192,
17
131071. The number 131071 (2
-1) is the largest magnitude that can be expressed as a FORTRAN integer. Fractional quantities and numbers larger than ±131071 require real numbers.

Rea I numbers* have two forms. They are simple decima Is such as: 0.0025, .4, - 57., 2.71828; or they
are numbers in decimal exponent form, a number multiplied by a power of 10. Examples:
Mathematical Form
6.023 x 10

FORTRAN Form

- 1 .66 x 1012
72 x 10

6.023E23

-1.66E-16
72E12

In general, a real number in decimal exponent form i"s expressed as ±nE±K where n may be an integer or
simple decimal, and K is an integer exponent from 0 to 99, inclusive.

Storage Modes - Another difference between PDP-7 FORTRAN II integers and real numbers is the manner
in which each is represented in core memory.
A FORTRAN integer is stored as a binary number in one 18-bit computer word. This representation, shown
schematically in Figure 5a. is called fixed point, because the decimal point is always considered to be
to the right of the rightmost digit.

Negative numbers are stored as the l's complement of their magnitude,

the leftmost bit being the sign bit.
A FORTRAN real number is stored as a binary number in floating-point representation. In this form, the
number consists of two parts: an exponent and a mantissa. The mantissa is a decimal fraction with the
decimal point assumed to be to the left of the leftmostdigit. The mantissa is always normalized; that is,
it is stored with leading O's eliminated in its binary form, so that the high order bit is always 1. The exponent as stored represents the power of 2 by which the mantissa is multiplied to obtain the value of the
number for use in computation.
There are two versions of the floating-point representation: normal, or three-word, mode and two-word
mode. They differ in the number of words of core storage required, and, hence, in precision of the number.
The normal mode requires three 18-bit words of memory for each number. The exponent, a signed 17-bit
integer (2's complement if negative), is stored in the first word. The mantissa is a 35-bit number stored
in the second and third words. The sign of the mantissa is kept in the high-order bit of the second word.
A negative mantissa involves a change of sign. Figure 5b. is a schematic representation of a three-word
floating-point number.

*This use of the term real should not be confused with the mathematical usage; in PDP-7 FORTRAN II
real applies only in the limited sense described above.

The second floating-point mode requires only two words of memory and can be used where space is at a
premium and precision can be sacrificed. The exponent and its sign occupy the first nine bits of the first
word; the mantissa occupies the rest of that word and all of the second. The sign of the mantissa is in the
high-order bit of the second word. A negative mantissa involves a change of si gn. Figure 5c. is a schematic representation of a two-word floating-·point number.
Sign

I I
0

Magnitude Complement of Mag. If Bi t 0 is 1

I
17

FORTRAN Integer

Sign
1

Exponent

I !
1
0

(2', comPlemett if negative)
2

I
0

Mantissa

I
I

Mantissa
1

17
b.

Normal Floating Point

Sign

[
0

,
f

Exponent

I
I

Mantissa

201 = +1
200 = 0
177 = -1
2

Mantissa
c. Floating Point, 2-Word Form

Figure 5

Number Representation, Floating Point

I
17

Variable Representation
The term "variable,1I as used in FORTRAN, means a quantity which may assume different values during
different executions of a program or at different stages of a program1s execution, hence, a variable name
is a symbolic representation of this quantity. A variable name is composed of one or more characters
according to three rules:
1. The only characters used in a variable name are A through Z and 0 through 9.
2. The first character must be alphabetic.
3. Only the first six characters of any variable name are meaningful; all characters
after the sixth are ignored by the compi ler.
Some examples of acceptable variables names are K, P51, ROB ROY, and EPSILON. The name ROB ROY
represents one variable, not two, because blank spaces are ignored by FORTRAN. Thus, ROB ROY,
ROBROY, or even ROBR OY are identical names and reference the same variable.
The compiler interprets the name EPSILON as EPSILO, since only the first six characters are meaningful.
Care is necessary in selecting variable names. For example, the two names, GEORGEl and GEORGE 2
are considered identical because of the six-character restriction.
Some incorrect variable names are 9S0RT (first character not alphabetic)and GO#5 (illegal character
included).
Since variables represent numeric quantities, the type of representation must be specified. In normal
programming, variable types are specified using the standard FORTRAN conventions, as follows:
Integer variable names must begin with one of the letters I, J, K, L, M, or N.
Real variables are designated by names beginning with any other letter.
Typical integer variable names are INDEX, KDATA, M359, L1ST8. Typical real variable names are
XZERO , COUNT, FICA.

Subscripted Variables - An array is a grouping of data. A column of figures, the elements of a vector,
a list, and a matrix are all arrays. In mathematics, an element of an array is referenced by a symbol
denoting the array and subscripts identifying the position of the element. For example, the sixth element

in a vector v is designated v 6. Likewise, the fourth element in the tenth column of a matrix b is identified
as b

10· In general, an element of an n-dimensional array m is designated by m.

.•

•

11'1 2 '1 3 ····,l n •

In'PDP-7 FORTRAN II, array elements are similarly identified. The array is provided with a name, subject to the same rules as the names of variables. The name determines the mc)de, integer or real, of all
the elements in the array. The subscripts which identify an element of the array are enclosed in parentheses and separated by commas. The two elements, v6 and b

10' in FORTRAN would have the following

form:

V (6)

B(4,10)

Subscripts may be quite diverse in form; in fact, a subscript may be any acceptable FORTRAN arithmetic
expression as long as it is integer-valued (i.e., floating-point quantities are not allowed).
a. X (3,3)
b. C(I+1,J+1)
c. N (1(1), J(1), K(2))
d. Y (J/3 + (K-4))
Figure 6

Example of Subscripts

Note that certain subscripts in Figure 6 are themselves subscripted. Subscripting may be carried to four
levels, although it is unusual to do so to more than two levels. Each subscripted subscript in Figure 6,
i.e., 1(1), and K(2), is itself treated as a subscripted variable.

CHAPTER
ARITHMETIC AND

DATA-SPECIFICATION STATEMENTS

The arithmetic statement relates a variable (V) to an arithm~tic expression (E) by means of the equal sign (=),
thus:
V=E
Such a statement looks I ike a mathematical equation, but it is treated differently. The equal sign does
not merely represent a relation between left and right members, but specifies an operation to be performed;
namely, replace the value of V with the value of E. A few illustrations of the arithmetic statement are
given in Figure 7.

VMAX=VO+A* TO

T = 2*PI*SQRTF(L/G)

c•

PI =3. 14159

THETA = OMEGAO*T + ALPHA*Tt2/2

MIN=MINO

INDEX = INDEX +2
Figure 7

Ari thmeti c Statements·

ARITHMETIC EXPRESSIONS
The elements of an arithmetic expression are of four types: constants, variables, functions, and operators.
An expression may consist of a single constant, a single variable, a function, or a string of constants,
variables, and functions connected by operators.
Constants are explicit numerical quantities. They may be integers, decimals, or numbers in decimal exponent form.
Variables represent quantities whose values are not implicit; they may be redefined during execution of
the program.

Functions are special forms of variables consisting of a name immediately followed by an argument enclosed
in parentheses. The function name represents a mathematical operation to be performed on the argument
such as finding the square root of a number or determining the sine or cosine of an angle. Certain basic
functions are provided by the FORTRAN system and are called library functions.

A detailed discussion of

functions is found in Chapter 5. Of interest here, however, is their treatment within an arithmetic expression: .
Whenever a function is encountered, it is evaluated and the result is treated as a
variable in the evaluation of the expression in which the function occurs.
Figure Se. and f. illustrate the use of functions as variables in an arithmetic: expression. Included in

thes~ examples are SINF(THETA) and COSF(THETA-1 .5), corresponding to the trigonometric functions
sine and c~sine, and SQRTF(X), the square root operation.
Operators are symbols representing the common arithmetic operations:
Exponentiation
Multiplication
Division
Addition
Subtraction
Equiva lence

Algebraic Expression
az

FORTRAN Expression

+ bz + c

(a 2_b 2)

(A t2-B t2)/(A+B)t 2

(a+b)2
4nr2

-3-

3z -2 (z+y)
4.25

(3*Zt2 - 2* (Z+Y))/4.25

a sin 9 + 2a cos (9-1.5)

A*SI NF(THETA)+2*A*COSF(THETA-l .5)

-3-

2rz

2* SQRTF(Z)/3

Figure S

Examples of Arithmetic Expressions

The important rule about operators in the FORTRAN arithmetic expression is that every operation must be
expl icitly represented by an operator symbol. In particular, the multipl ication sign (*) must never be
omitted. Likewise, since no superscript notation is available, a symbol for exponentation (t) is provided.
Figure 8 demonstrates the properties of arithmetic expressions. Each expression is shown with its corresponding algebraic form.

Evaluation of an Expression
Normally, a FORTRAN expression is evaluated from left to right just as an algebraic formula. As in algebra, however, there are exceptions. Certain operations are always performed before others, regardl ess
of order. This priority of evaluation is as follows:
1. Expressions within parentheses

()

2. Unary Minus*
3. Exponentiation
4. Multipl ication
Division

5. Addition
Subtraction

6. Equivalence

The term "binding strength" refers to an operator's relative position in a table such as the one above.

it the operations are Iisted in the' order of descending binding strength. Thus, exponentiation has a greater
binding strength than addition, and multipl ication and division have equal binding strength.
The left-to-right rule can now be stated a I ittle more precisely:
Operations are performed in order of decreasing binding strength. A sequence of
operations of equivalent binding strength is evaluated from left to right.

Use of Parentheses
To change the order of evaluation, parentheses are required. Thus, the FORTRAN expression, A-B+C is
algebraically evaluated as (a-b)+c, whereas A-(B+C) is evaluated as a-(b+c).

*The unary minus is th~ operator which precedes a quantity whose value is to be negated. A unary minus
is recognized by the fact that it is preceded by another operator, not by an operand. Example:
A + B t- 2/C - D
The first minus (indicating a negative exponent) is unary; the second (indicating a subtraction) is binary.

The expression

is evaluated as

A/B/C

A tBtC
Figure 8d. illustrates the use of parentheses for grouping subexpressions within an expression. In algebra
several devices are available for distinguishing between levels when nesting subexpressions, such as square
brackets ([ J) and rococo brackets

(i r). In FORTRAN, only parentheses are: available, so the programmer

must be especially careful to make certain that parentheses are properly paired; that is, in a given expressi on, the number of left parentheses must be equa I to the number of ri ght parentheses.
The Replacement (Equals) Sign
The equal sign has the lowest binding strength of all the operators; the whole of the expression on the
right is evaluated before the replacement operation is performed.

In an arithmetic statement, the value

of the expression to the right of the equal sign replaces the value of the variable on the left.
By this definition the statement in Figure 7f. would mean, "Add two to the current value of INDEX. The
resu It is the new value of INDEX. II
All variables occurring to the right of an equal sign must have been previously defined. If the variable
on the left of the equal sign was previously undefined, it will be defined by the arithmetic statement.

Internal Arithmetic Statement
The most important result of treating the equal sign as an operator is that it may be used more than once
in an arithmetic statement. Consider the following:
Q = A/(V=SQRTF(2* G*Y))
The interna I arithmetic statement, V=SQRTF(2* G* Y), is separated from the rest of the statement by parentheses. The complete statement in this i "ustration is a concise way of expressing the following type of
mathemati ca I procedure:
Let

q = a/v

where

I29Y7'

In the single FORTRAN statement, both of these equations are evaluated and values are assigned to Q
and V.

Another result of treating the equal sign as an operator is that there may be a series of replacements,
A=B=C=D, in a single FORTRAN statement.

Note that since the operand to the left of an equal sign must

be a variable, only the rightmost operand, represented by D above, may be an arithmetic expression.
The statement is interpreted as follows: "Let the value of expression D replace the value of variable C,
which then replaces the value of variable B" and so on*.

In other words, the value of the rightmost

expression is given to each of the variables in the string to the left. A common use for this construction
is in setting up initial values:
VZER O=5ZER O=AZER 0=0
T=T 1=T2=T3=60
P=P0=4*ATM-K

Mode of Computation
PDP-7 FORTRAN II does not restrict the use of variable types within an arithmetic expression.

Integer and

real variables and constants may be freely mixed. The order in which the quantities are encountered during
the left-to-right evaluation determines the mode of computation; however, the result is always stored in
the mode of the left-hand variable of the arithmetic statement.

In general, the following rules apply:

1. For any expression, computations are carried out in fixed point until a floatingpoint quantity appears; thereafter, all computations are carried out in floating point.
2. An expression in parentheses is considered separately from the main computation;
thus if a subexpression contains only integers, it is evaluated in fixed point.

necessary, the result is converted into floating point.
3. The value of an expression on the right of an equal sign is converted to the mode
of the left-hand variable before storage, if necessary.
The following example illustrates the method of performing calculations in an arithmetic statement.

*This may seem at first to violate the left-to-right rule. Whenever an equal sign is encountered in scann ing a statement, it cannot be executed until all operations of higher binding strength have been performed.
Thus, execution of each equal sign (replacement) is deferred until the expression on the right has been
evaluated. The replacements then occur in reverse order as the evaluation works back to the leftmost
variable.

In evaluating the statement
A = C*V* (J+2)
Tl = C*V floating point

let

T2 = J+2 fixed
the resu It, T2, is converted to floating point; then
A = T1*T2 floating

DATA-SPECIFICATION STATEMENTS
Data-specification statements fall into two categories: those relating to data handl ing and storage; and
those deal ing with input/output operations. This section discusses the first clctegory (except for the
COMMON statement which is directly related to subprograms and is describE~d in Chapter 5); the other
is discussed in Chapter 4.

Dimension Statements
Array names must be identified as such to the FORTRAN compiler. Three items of information must be
provided in any program using arrays:
1. Which are the subscripted variables?
2.

How many subscripts does each have?

3. What is the maximum dimension of each subscript? (When an alrray is used, a
certain amount of storage space must be set aside for its elements, hence, this
requirement. )
All the above information is provided by the following specification statement type:
DIMENSION A(I,J,K,L), B(I,J,K,L), C(I,J,K,L), ....
where A, B, and C are array names, and the integer constants I, J, K, L, are the maximum dimensions
of each subscript.
The rule governing the ~se of array names and the DIMENSION statement is as follows: All array names
must appear in a DIMENSION statement, and the DIMENSION statement must precede the first use of
any of the names appearing in its list.
DIMENSION LlST2 (30), MAT3(10,20), RE GRES(2, 2, 5)
In the statement above (under normal FORTRAN variable naming conventions), the names LlST2 and MAT3
designate integer arrays; that is, each element is an integer. The third name, RE GRES, designates a real

array. The first array is a I ist of 30 el ements maximum, so that 30 words of storage are set aside for its use.
The second array is a matrix of 10 rows and 20 columns, making a total of 200 elements requiring 200 words
of space. The third array is three-dimensional and real. There are 2 x 2 x 5 = 20 elements, each requiring
3 words of storage for floating-point representation, so that 60 words will be set aside for the array. A
maximum of 4000 words is normally set aside for storage of arrays.
If a subscript is subscripted, the name of the higher-level subscript must also appear in a DIMENSION
statement.

For example, a program in which the following statement appears:
A(I(l), J(2), K(l 0)) = B(I(l 0), J(2), K(l))

could contain a DIMENSION statement like the following:
DIMENSION A (5,5, 10),B(10,5,5),1(10),J(10),K(10)
If an array name is to be passed as an argument from one program to another (e. g., a subroutine provides
values to a variable array in the call ing program), both the call ing program and the subroutine must agree
in floating point storage mode (three-word or two-word). This restriction does not apply when the argument
is a specific array element rather than an array name.
When referencing dimensioned variables, use the correct number of subscripts. For example:
DIMENSION

A(lO, 10, 10)

A(3,4,6)

42 (correct).

A(705)

42. (will cause haphazard
results at object time) .

A= 3.

. (will also cause undesired
resul ts).

Floating-Point Storage Specification
Unless otherwise indicated, all real numbers in a given program are stored in three-word form where 35 bits
are reserved for the magnitude of each variable or constant.

If the two-word form is desired (27 bits re-

served for magnitude), the following specification statement must appear as the first statement of the program to which it appl ies:
2WORD
The two modes may not be mixed within anyone program or subprogram, and they may only be mixed between programs when the level (depth) of call is at most one; e. g., a subprogram does not call other
subprograms. (Refer to page 5 for a discussion of storage modes.)

CHAPTER 3

PROGRAM CONTROL
Ordinari Iy, FORTRAN statements are executed in the order in which they are written unless contrary
instructions are given. The instructions provided by the program control statements a II ow the programmer
to alter the sequence, repeat sections, suspend operations, or halt the program.

BRANCHES AND LOOPS

Unconditional GOTO Statements
There are various ways in which program flow may be directed. As shown schematically in Figure 9, a
program may have a straight-line sequence a. , branch to an entirely different sequence b., return to an
earlier point c. I or skip to a later point d.

b •....------1

Fi gure 9

Schematic Representation of Program Branches

All of the branches can be performed in several ways, but the simplest is by the statement
GOTO n
where n isa statement number used in the program. This statement is described in the following example,
which also illustrates the construction of a loop, the name given to program branches of the type shown
in Figure 9c.

SUM OF FIRST N INTEGERS BY ITERATION
KSUM=O
INUM=l
KSUM=INUM+KSUM
INUM=INUM+1
GOTO 2
END
Fi gure 10

Integer Summati on

In Figure 10, the sum of successive integers is accumulated by repeated additiion. The main computation
is provided by the three-instruction loop beginning with statement 2. The statements preceding this loop
provide the starting conditions; this is called the initialization. The partial sum (KSUM) is set to 0, and
the first integer is given the value of 1. The loop then proceeds to add the integer value to the partial
sum, increment the integer, and repeat the operation.

The IF Statement
The program shown in Figure 10 performs the required computation, but there is one flaw: the loop is
endless. To get out of the loop, iteration must be stopped an~ the next step must be determined.
The IF statement fulfills both requirements. It has the following form:
IF(e)k,l,m
where e is any arithmetic expression, and k, I, and m are statement numbers. The IF statement is interpreted in this way:

If the value of e is less than 0, go to statement k.
If the value of e is equal to 0, go to statement I.
If the value of e is greater than 0, go to statement m.
Thus, the IF statement makes the decision of when to stop by evaluating an expression, and also provides
program branch choices which can depend on the results of the evaluation. Figure 11 illustrates the use
of the IF statement in the integer summation problem of Figure 10.

Figure 11

SUM OF THE FIRST 50 INTEGERS
KSUM=O
INUM:=l
KS UM:=I N UM+KS UM
INUM:=INUM+l
IF (lNUM-50) 2,2,3
STOP
END

Use of IF Statement in Integer Summation Pr()blem

In this example, the initialization and main loop are the same as for Figure 10, except that the GOTO
statement of the earlier program has been replaced by an IF statement. This statement says: If the value
of the variable INUM is less than or equal to 50 (which is the same as saying that the value of the expression INUM-50 is less than or equal to 0), go to statement 2 and continue the computation. If the
value is greater than 50, stop.
A loop may also be used to compute a series of values. The following example is a program to generate
terms in the Fibonacci series of integers, in which each succeeding member of the series is the sum of
the two members preceding it: k =k l+k ·2.
n nn-

FIBONACCI SERIES, 100 TERMS
DIMENSION FIB (100)
FI B (1)=1
FIB (2)=1
K=3
FI B(K)=FI B(K ... l) + FI B(K-2)
K=K+l
I F (K - 100) 5, 5, 10
STOP
END
Figure 12

Fibonacci Series

In this program, initialization includes a DIMENSION statement to reserve space in memory for the results, and two statements which provide the starting values necessary to generate the series. Each time
a term is computed, the subscript is indexed so that each succeeding term is stored in the next location in
the table. As soon as the subscript becomes greater than 100, the calculation stops.

DO Loops
Iterative procedures such as the loop in Figure 12 are so common that a more concise way of implementing
them is warranted. In that example, three statements were required to initialize the subscript, increment
it, and test for termination. The DO statement combines a II these functions:
DO n i=kl,k2,k3
where n is a statement number, i is a simple integer variable, and kl, k2, and k3 are simple integer variables or constants used as indexing parameters to provide, respectively, the initial values of i, the final
(terminating) value of i, and the indexing increment of i. The DO statement may be paraphrased as:
liDO through statement n for i = kl; after statement n is completed, increment i by k3; if i is less than or
equal to k2, repeat the sequence; otherwise exit from the DO loop and continue on in the program. II
Upon normal exit from a DO loop, the value of the DO variable (i) will be the one generated at the final
test, that is, greater than k2. If k3 is equal to 1, it may be omitted. Figure 13 shows the Fibonacci series
calculation programmed using a DO loop.
19

Figure 13

FI BONACCI SERIES, 100 TERMS
DIMENSION FIB(100)
FIB (1 )== 1
FI B (2)==1
DO 5 K=3, 100
FI B(K)=FI B(K -1 )+FI B(K-2)
STOP
END

Fibonacci Series Calculation Programmed as a DO Loop

The DO statement is interpreted thus: Do the sequence of statements up to and including statement 5,
then index K by 1. If the new value of K is greater than 100, go to the statement following statement 5.
DO loops are commonly used in computations with multiple- subscripted variables.
usually necessary to perform loops within loops.

In these cases, it is

Such nesting of loops is permitted in FORTRAN. A

simple illustration is the initialization of array storage, shown in Figure 14.
Initialize two 30 x 50 matrices and one 30-element vector, by setting the allotted storage space to O.
Note that in PDP-7 FORTRAN II, the initial condition of variable storageisneverimplicitly cleared.
C

.10
20

INITIALIZATION OF STORAGE
DIMENSION MATl (30,50), MAT2(30,50), VEC~3(30)
DO 20 1=1, 30
DO 10 J=l, 50
MA Tl (I, J)=O
MAT2(1,J)=0
VEC3(1)=0

Figure 14

Initialization of Array Storage

This sequence causes storage to be cleared in the inner loop column by column for each matrix, while the
outer loop advances the column index and clears the elements of the vector.

Genera I Ru Ies for DO Loops
The following general rules about DO loops must be observed:
1.

DO loops may be nested, but they may not overlap.

Nested loops may end on

the same statement, but an inner loop may not extend beyond the IOlst statement
of an outer loop.

Figure 15 schemcltically illustrates permitted and forbidden

arrangements.

Those in 150. are permitted; loops 5, 6, and 7 end on the same statement.
The arrangements in 15 b. are not permitted; loop 2 ends on a DO statement,
loop 3 extends beyond outer loop 1 •

1
2

,....--- 2
~>---3·

II""

a.
Figure 15

DO Loops

2. A program branch may not occur from a point outside a DO loop to a point inside,
or from an outer DO to within an inner DO.

Branches out of DO loops are permissible,

however. Figure 16 illustrates this rule.

[I)

r;, .~I-------'
.
~~
6)
7

Figure 16

Program Branching in DO Loops

Branches 2, 5, 6, and 7 are permitted; branches 1, 3, and 4 are not.
3. A DO loop may not end on a program branching stat~ment (GOTO, IF) or another
DO statement.

The CONTI NUE Statement
Since a DO loop may contain alternate courses of action (such as branches tOI other parts of the loop, or
out of the loop entirely), programmers frequently wish to make the last executable statement of the loop
a test to determine which of the alternatives is to be taken.

However, rule ~3 of the above section forbids

a DO loop to end on an IF or GOTO statement. To avoid this, the CONTINUE statement is provided as
a dummy statement. It performs no action or computation, but provides a termination for any DO loop:
n

CONTINUE

where n is the statement number specified by the DO statement that initiated the loop.
A CONTI NUE statement is not restricted to terminating DO loops; it may be used anywhere in a program;
e.g., to provide points at which future program segments may be inserted.

Computed GOTO
The GOTO statement described previously is unconditional and provides no c:dternatives. The IF statement offers a maximum of three branch points. One way of providing a greater number of alternatives is
by using the computed GOTO, which has the following form:
GOTO (k 1, k2, k3, ..• kn), i
where the k's are statement numbers, and i is a simple interger variable which may take on values of 1,
2, 3, ••• n according to the results of some previous computation. For example,
GOTO (5,7,5,7,5,7,10), IVAR
causes a branch to statement 5 when IVAR=l, 3, or 5, to statement 7 when IVAR=2, 4, or 6, and to statement 10 when IVAR=7. If IVAR is not one of the possible (legal) values, the GOTO will be ignored and
control wi II pass to the next statement.

If an argument of a subroutine is used as the argument of a computed GOTO statement in the subroutine,
the argument must be redefined (with a different name) in the subroutine; e. g.:
CALL SUB(JAY)
SUBROUTI NE SUB(KAY)

MAY = KAY
GO TO (1,2), MAY
Otherwise, the address of JAY wi II be used rather than the contents of JAY.

Assigned GOTO
A slightly different way of providing a multibranched switch is by the assigned GOTO, which has the
following form:

where i is a simple integer variable and the k's are statement numbers. In use, the variable i is assigned
a value of one of the numbers in the list by an ASSIGN statement of the form
ASSIGN k to i
where k is one of the statement numbers in the list. The ASSI GN statement must precede the GOTO in
order of execution. For example,

ASSIGN 30 TO IFORK
25
30

GOTO IFORK (20,30,40,50)
ASSIGN 40 TO IFORK

GOTO 25
A=B+C

The first time statement number 25 is executed, the program branches to statement 30 where IFOR K is
altered so that the next execution of statement 25 initiates a branch to statement 40. An alternate form
of the ASSIGNED GOTO dispenses with a list of statement numbers. It consists of the following:
GOTO i
where i is an integer variable whose value is established by an assign statement. This value must correspond to one of the statement numbers in the program.

PROGRAM TERMINATION

The STOP Statement
A program which is arranged so that the last written statement is the final and only stopping place needs
no specia I termination indicator. The END statement automatically produces the fina I ha It. Most programs, however, contain loops and branches so that the last executed statement is often somewhere in the
middle of the written program. Often, there may be more than one stopping point. Such terminations
are indicated by the statement:
STOP

This causes a final, complete halt; no further computation is possible.

If mOire than one final halt is

possible, each can be identified by a number as follows:
STOP n
where n is an octal integer which is displayed in the console ACCUMULATOR lights when the program
stops. This feature is very useful when several stops are possible, such as stops in error routines, and it
is desirable to know which one was reached.

The PAUSE Statement
The PAUSE statement allows suspension of operation for a time and then restal"ting the program by manual
control. This is frequently necessary when the operator loads and unloads tapes in the middle of a program.
This kind of temporary halt is provided by the following statement:
PAUSE n
The octal integer n appears in the AC lights when the pause is effected. Depressing the CONTINUE
switch on the console resumes operation of the program.

CHAPTER 4
INPUT/OUTPUT STATEMENTS

In previous examples, all necessary information has been in the computer memory. Of course, these
programs are read in by a spec ial loader, but the programmer must provide for the input of data and the
output of results associated with his program.
For any input or output procedure, several items of information must be specified:
1. The direction of transfer (READ or WRITE).

2. The I/O device.
3. The amount, type, and location of the information to be transferred.
4. The arrangement of the data.

In FORTRAN terms, the order and format of the in-

coming or outgoing data must be specified.
To provide a" of the information listed above, two statements are required for every data transfer between
core memory and an external device. The first three items are suppl ied by the input/output statement, an
example of which is shown in Figure 17; the fourth is specified by the FORMAT statement.

+
A _ __

device
number

data list

tA, B(5) ,I, ((C(J, K) ,J=M, N, I), K=M, N)\

operation

Format Statement

Number

Figure 17

I/o Statement

INPUT/OUTPUT ASSIGNMENTS
The direction of the data transfer is desi gnated by the first word in the I/O statement. A" incoming
transfers are initiated by a READ statement; all outgoing transfers by a WRITE statement.

The use of a device number, which follows the first word and specifies the external device involved in the
transfer, eliminates the need for additional commands such as PUNCH, PRINT, etc. These device numbers are as follows:
INPUT
Device
Number

OUTPUT
Device
Number

Device

Keyboard

Teleprinter

Perforated Tape Reader

Perforated Tape Punch

Card Reader

PDP-4 Line Printer

PDP-7 Line Printer

The numbers 100-999 are assigned to magnetic tape; DECtape (microtape) is clssigned the numbers from
1000 up. These two devices require special forms of an I/o statement, described later in this section.
The format statement number is the third item in the I/O statement.

It refers to a FORMAT statement

which determines the arrangement of the data being transferred. The format statement number is separated
from the device number and from succeeding items by commas.

Except for trcJnsfers of binary data to or

from magnetic tape or DECtape all I/O transfers must be accompanied by a FORMAT statement. The remaining items in the I/O statement are components of the data list.

THE I/O DATA LIST
The last part of the I/O statement is a list, the elements of which spec ify the locations in memory and the
number of data elements being transferred. These elements, separated by commas, may be of four types:
Variables (unsubscripted)
Array elements (subscripted variables)
Array transfer express ion
Constants (output lists only)
The list in the statement in Figure 17 contains four elements. These are, in order, a real variable, an
array element, an integer variable, and an array transfer expression enclosed in parentheses.
The array transfer expression transfers whole arrays or sections thereof, under control of a single I/O
statement. The expression consists of an array name with subscripts and a series of internal arithmetic

statements which specify the lower and upper I im its of each subscript and the increment between elements.
The upper limit must not exceed the maximum value for that subscript given in the DIMENSION statement

If the increment is 1, it may be omitted.

in which that array name appears.

The function of the array transfer expression is shown in the I/O statement in Figure 17. The elements
of array C are to be read into core. Every element in the K dimension between the limits M and N, and
every Ith element in the J dimension between the I imits of M and N, are read into the computer. When
the loops are exhausted, the reading stops. The limit parameters I, M, and N, must be defined before
they can be used in the expression.
The array transfer expression is a sequence of nested DO loops; the operations described in the preceding
paragraph would have to be programmed as follows if the array transfer expression were not available:

DO 15 K=M, N
DO 15 J=M, N, I
READ 3, 100, C(J,K)

The following forms produce the indicated results:
READ 3,100, (C(I,J), 1=1, 10)
Result

C(l, 1) C(2,2) C(3,3)
C(4,4) ... C(l 0, 10)

READ 3, 100, (CC(I), B(I), 1=1, 10)
Result

FORTRAN diagnostic errors

Ordering of Data Within an Array
In the language of matrix algebra, the data ordering specified by this array transfer expression is by columns.
If M=l, N=5, and 1=2, the elements of C must be ordered:

Note that should one reverse the left-to-right arrangement of the arithmetic expressions defining K and J
in the array transfer expression of Figure 17, the data must be ordered by columns:

That is, the ordering of the subscript defining expressions in an array transfer expression is independent
of the subscript ordering in the array variable. The subscript encountered in the first definition expression,
proceeding from left to right, varies most.
27

I/O SPECIFICATION STATEMENTS

Data Fields
The space allotted to an item of data is called t~e data field. The width of the data field is the number
of character positions occupied by the item. The width may be greater than jrhat required to hold all the
characters of the item of data including the sign, but no more than one item may appear in a field.

For

example, a five-digit integer may appear in a field eight positions wide {empty positions are denoted by
the letter b, for blank}:
bbb34729
An item of data may be numeric {numbers}, non-numeric {alphanumeric test or coded characters}, or blank.

Data Field Formats
Information may be read in or written out in one of six data field formats: three numeric and three nonnumeric.

Each format is designated by a single letter contained in the format specification. The format

specification indicates the type of data field {numeric or alphanumeric}, the length of the data field, the
form of the item it contains, and the storage mode of the item in the computer. The properties of the six
format specification letters are summarized in Table 1; each specification type is described in detail in
this chapter.

TABLE 1
Format
Spec. Letter

SUMMARY OF FORMAT SPECIFICATION LETTERS

Type of
Field

Storage
Mode

Input

Output

numeric

decimal,
decimal exponent

floating point
number

decimal exponent

numeric

decimal,
decimal exponent

floating point
number

decimal,
decimal exponent

numeric

integer

fixed point
number

integer

non-numeric

any characters
and/or blanks

none

blank space

non-numeric

text

packed Flexowriter
FIODEC

text

non-numeric

text

packed Line Prinl"er
FIODEC

text

The Format Statement
Each format specifi cation provides informati on about one data fie Id. To determi ne the arrangement of these
fields, for both input and output, the format specifications must be combined in a FORMAT statement, as
shown in Figure 18.
a.

100 FORMAT (2E 12 .2,3X, F5 .2) - numeric fields

200 FORMAT (8HRAW DATA,5A3) - alphanumeric fields
Fi gure 18

FORMAT Statements

Following the word FORMAT is a statement list made up of format specifications, separated from each other
by commas, and the whole enclosed in parentheses. Formats of all six types may be freely combined; however, the format specification, the item of data, and (H, X expected) the variable type in the I/O statementl ist must all correspond.

If successive data fields have identical formats, it is not necessary to write out each specification in full;
instead, the format specification may be preceded by a repetition count, equal to the number of identical
data fields. The repetition count may not be larger than 15. For example, the first member of the I ist in
Figure 18a. is:
2E12.2
This indicates that the next two data fields have identical E-formats. Likewise, 3X indicates three successive characters of X-format. However, groups of more than one data field may not be repeated by
preceding the group with a repetition number.

For example 6(F5 .2, 3X) is illegal.

Every FORMAT statement must be identified by a statement number so that it can be referenced by an
I/O statement. When an I/O statement is executed, its data I ist and the list of format specifications in
the corresponding FORMAT statement are scanned from left to right. Each item of data is matched with
a format specification and transferred according to the format specified. This procedure continues until
the I/O data Iist is exhausted.

If the format I ist runs out before the I/O operation is completed, the

format scan returns to the last previous left parenthesis and continues from that point.
If there are no internal parentheses in a format list, the scan would return to the beginning and repeat
the format I ist.

If the I/O Iist is exhausted before the format list, the remainder of the format I ist is

simply ignored.

Format Spec ifications
The following paragraphs discuss the properties of each data field format, and the form of data permitted
to each. The three numeric formats are described first, followed by the three non-numeric formats. The
letter r in all cases symbol izes the optional repetition count which can precedle the format specification.

Integers: I-Format
Integer fields are specified by the letter I. The general form of the specificaf'ion is

rlw
where r is number of times specification is to be used and w denotes the field width including one position
for the sign, whether or not it appears; that is, w-l digits are allowed; e.g., 15, 417.

If the field width

is greater than 7 it will be set to 7. On input, the field must contain a FORTRAN integer not exceeding
a magnitude of 131071. The integer may be signed or unsigned and may be placed anywhere within the
field as long as there are no blanks embedded in the number. Input is converte!d to fixed point for storage.
The following are examples of I-format input.
Specification

Acceptable Input

Unaccep'tabl e Input

32
+5012
-317

34729 (too many characters)
50b31 (embedded blank)
3 .57b (not an integer)

On output, integers are right justified within the field.

Positive integers are unsigned.

If an integer is too

large to fit in the field, least significant digits are truncated. The storage mode for I-format output must
be fixed-point.

Real Numbers: F- and E-Formats
Real number fields are specified by the letters F and E. The general forms are!
rFw.d

rEw.d

where w denotes the total field width inc! uding the dec imal point, exponent, and sign, and d spec ifies
the number of digits to the right of the decimal point. w is limited to a maximum of 31 characters; d can
be as large as 15. If an exponent is to be specified in input data, the charac'ter E must be present.
Both format specifications permit the same type of input. An incoming numbelr may be in one of three forms:
1. A simple decimal: 95.34729; -7.132
2. A decimal exponent: 1 .66E-16; -6.032E+23; 1.66-16; -6.032B23 (-6.032+23)
3. A string of digits with no indication of magnitude: 9534729; -6032E-23
30

Incoming numbers may be signed or unsigned and placed anywhere within the field. As with integers,
there may be no embedded blanks though a blank preceding an exponent is allowed, thus: 1. 32E 36.
If the incoming number contains an explicit decimal point, the fraction delimiter (d) of the format specification is ignored. If there is no explicit decimal point, the number must be followed by either an exponent or the end of the field, but not by blanks. A decimal po int is inserted in the number, independently
of the exponent value according to the d specification only if there are at least d digits in the number. If
there are fewer than d digits, the decimal point is placed to the right of the number, regardless of d. The
following illustrates the effect of the fraction del im iter.

If the specification is

And the' incoming
fie Id appears as

E12.2

bbbbb9534729

95347.29

F10.5

bb953.4729

953.4729 (explicit
decimal point overrides)

E10.2

b+l.66E-16

1.66E-16

El0.2

bbb166E-16

1.66E-16

Fl0.5

bbbbbbb222

222.0 (less than 5 digits
input)

The magnitude of
the number is

Both E- and F-format causes the incoming data to be converted to floating-point for storage.
The two formats differ only in the form of output each produces. E-format output always appears as a
decimal exponent with the exponent signed and the E omitted. The number is right justified in the field.
Positive numbers are not signed. The following illustrates E-format output.

If the specification is

E10.3
E12.5
E12.2

And the magnitude
of the stored number is
1.66 x 10-

23
-1.324 x 10
23
- 1 .324 x 10

The output appears as

bbb.166-15
bb- • 13240 24
bbbbb- • 13 24

The important points to observe in these examples are:
1. The printed number is normalized; that is, scaled so that it is less than 1 .0 and no
zeros appear immediately to the right of the decimal point.

2. The E representing the exponent is missing, and the exponent itself is signed whether
it is positive (blank) or negative (-).
3. If the fractional part is too large to fit in the space reserved for it, the least significant digits are truncated.
F-format output is in the form of a simple decimal. The number is right justified in the field, and the
decimal point is placed according to the format spec ification. Positive numbers are unsigned.

Fractional

parts are truncated if they would overflow the space reserved.

If the specification is

F9.4

And the magnitude of
the stored number is
953.4729

The output appears as

b953.4729

F12.5

.•• 007315 x 10

F10.2

55.9328

bbb-73.15000
bbbbb55.93

If F-format is specified, and the number to be printed is so large that the intE~gral part would not fit in
the available space, the number is automatically printed under E-format. For example,

If the format specification is
and the stored number has a value of
the format is interpreted as
and the number wi II appear as

F10.5
57329.46
E10.5
.5732905

For both formats, stored data must be in floating-point form for output. The Field width w must include
one position each for the sign and the decimcJI point; and in the case of E-format, three positions for the
signed exponent.

Non-numeric Fields: X-Format
One way to separate items of data for readability is to provide wide enough fields in the format specifications so that there wi" be some Ieading blanks. Another way to separate items is by using the X-format
specification, whose only function is to indicate the presence of a blank position. A string of blank
spaces is indicated by a repetition count before the X:
rX

On input, an X-format specification causes the input scan to skip ahead the number of spaces specified
by the repetition count and continue reading input from that point using the succeeding format specifications in the list.
On output, the X-format causes the number of spaces indicated by the repetition count to be inserted between the preceding and following items of data. For example, the specification
F5.2, 3X, F5.2
causes the output of two items of dec imal data to be separated by three blank spaces.
When reading FORTRAN produced paper tape input, a 1X format specification may be used wherever a
slash V) appears in the output format statement which produced the tape. The slash causes a carriage return to be punched following the last field. This is read as a blank item (f1) unless the X specification
skips the carriage return character. A more detailed description of field del imiters appears on page 36.

Non-numeric Fiel ds: H-Format (Hollerith)
The output of text such as table headings, captions, instructions to the computer operator, and descriptive
information is done by including the text expl ic itly within the FORMAT statement, using the H-format,
which specifies that the characters immediately following the H are to be taken as an item of textual data.
To handle a string of text, the total number of characters, including blanks, is counted and substituted
for the repetition count. An error will result if the number of characters is counted incorrectly. Figure l8b. shows a FORMAT statement which contains an H-format specification.

Note that the field

count 8 corresponds exactly to the number of characters and blanks in the field.
The programmer may mix H-format with other specifications in a format I ist. On output, the I/O data
list scan is suspended when an H-format specification is encountered, the text in the Hollerith field is
printed, and the data I ist scan resumes. If an output statement is to transfer H-format information only,
the data I ists may be om itted. Hollerith text is packed three characters to a word and stored in Flexowriter FIODEC code. Alphanumeric (A-format) information is stored 1, 2, or 3 characters per word, right
justified, in line printer FIODEC code (see PDP-7 Users Handbook, F75, page 178 and Appendix 1).
The information in the following format statement
50

FORMAT (41 HSATELLITE TRACKING DATA, CAMBRIDGE, MASS./
23HTELOS I, SEPTEMBER 1964)

would be printed on the teleprinter by the statement
WRITE 2, 50

and would appear as follows:
SATELLITE TRACKING DATA, CAMBRIDGE, MASS
TELOS I, SEPTEMBER 1964

Non-numeric Fields: A-Format
Frequently, it is desirable to vary text analogous to data. For example, a bill ing program may process a
larger number of accounts in the same manner with identical output format fc)r each except for the name
of the person associated with the account.

It would be burdensome to write a long sequence of FORMAT

statements with Hollerith fields and make frequent corrections simply to store all the account names.
The A-format specification allows the user to both REA.D and WRITE textual information.

Its general form

is
rAn
where r designates the number of 18-bit words required to store the charactelrs of text in the data field.
On input, characters are read and packed 1, 2, or 3 to a word depending on the count n. On output,
the stored words contain packed text, and 1, 2, or 3 characters are printed from each according to the
count n.

(The number of characters is r x n.) In the I/O statement, the paclked text is designated by an

integer variable name.

If a repetition coun"t accomodates a long string of text, the variable name is

subscripted; the value of the subscript, r, is the number of words of packed text. Such an array name must
appear in a DIMENSION statement. Since r ,:S15, n ,:S3, the format specific:ation cannot be greater than
15A3. To read a large number of characters, FORMAT (A3) is sufficient sinl:e the specification may be
indefinitely repeated.
To illustrate the use of A-format, take a hypothetical billing program. Assume that input is from paper
tape and output is on the teleprinter. The first item on paper tape for each (]ccount is the name of the
account in the first 36 character positions and no other information. To read this information, the following two statements would suffice (here r x n==36, the number of characters):
READ 3, 300, (NAMACC(I), 1=1, 12)
300

FORMAT (12A3)

The information in the 36 character positions is read into the 12 locations designated by the array name,
NAMACC; the text is packed 3 characters to a word.
To print out A-format, the following statement is necessary:
WRITE 2, 300, (NAMACC(I), 1=1, 12)

The A-format is also useful when the same program runs over a long period of time and the date of each
run is recorded. A date can be provided with the input, a location reserved for it, and the information
transferred using an A-format specification.

INPUT/OUTPUT DEVICES

Data Organization

Records
In every I/O device, data is organized into records. Because of the dissimilarity of devices, the definition of a record varies. Table 2 lists the I/O devices and the definition of a record for each.

TABLE 2

DEFINITION OF A PHYSICAL RECORD FOR I/O DEVICES

Device

Physical Record Definition

Keyboard and Teleprinter

The information typed on a single I ine (maximum 72
characters) .

Perforated Tape Reader, Punch

The information punched between two carriage returns
(practical maximum 72 characters, for compatibil ity with
other devices).

Line Printer

120 characters (one line).

Magnetic Tape and DECtape

The information contained between two record gaps
(blocks for DECtape and delimiters for magnetic tape;
maximum record length is 256 characters or 256 binary
words). One character per field and one character for
an end of record must be allowed for overhead on all
tape records.

Normally, one FORMAT statement corresponds to one record and the programmer must be careful that the
total number of characters in the format specifications, including repetitions, does not exceed the maximum for one record on the respective device.

Multirecord Formats
To make the arrangement of output data as flexible as possible, a single FORMAT statement can specify more
than one record. The method can best be illustrated by an example. The following FORMAT statement,
50

FORMAT (F12.2, 5X, 316, 2E15.5, 17)
35

causes the associated output to be printed on a single line. If the statement is changed to read
50

FORMAT (F12.2, 5X, 316/2E15.5, 17)

the insertion of a slash (/) in place of the comma after the third specification causes the remaining data
to be written as a new record on the next line.
In general, whenever a slash appears in a FORMAT (other than an H-format) statement, it terminates the
record.

If two slashes appear in succession with no interven ing spec ifications, the effect is the same as

if an empty record were transferred. For example, if two slashes were inserted instead of one in the
illustration:
50

FORMAT (F12.2, 5X, 316//2E15.5, 17)

and the data were written on the teleprinter, the result would be a line of delta, a blank line, then another
I ine of data. Use of multirecord formats greatly increases the flexibil ity with which the programmer may
arrange tabular data for output. Tables 3 and 4, respectively, indicate the leffects and I imitations of
multirecord formatting for input and output operations.

TABLE 3
Cards
Field Delimiters1 Apostrophe
Effect of
Field Delimiter

Record DeIimiter 2

INPUT FORMAT

Paper Tape

Teletype

Tab

Terminates
current field
if reached
before the
count in the
format statement runs out.

Carriage
return

Carriage return-I ine
feed

Magn~etic Tape

DECtape

Tab equivalent
code

Terminates
if reached
before the
count iin the
format stateformat runs out.

Terminates
current field
if reached
before the
count in the
format stateformat runs out.

Carria!~e return
equivalent code

Carri age return
equivalent code

curren:~ field

1 Field del imiters are never required on inpu1' but will have the indicated effE~ct if present. They are
always ignored when the first character of any field (except in A-format where they should never be used;
the only legal characters for A-format are the Anelex character set).
2 Record del imiters are never required on input except for magnetic and DECtape where they were produced
by the system, or where needed for the correct operation of the slash fu~ction as when using paper tape.

TABLE 3

INPUT FORMAT (continued)

Cards

Paper Tape

Effec t of Record Delimiter

Terminates the
current field
if reached
before the
count in the
format statement runs out
and terminates
the card.

Terminates
the current
field if
reached before the
count in the
format statement runs out.

Terminates
Term i nates the
the current
current fie Id
field if
if reached
reached bebefore the
count in the
fore the
format statecount in the
format state- ment runs out
ment runs out. and terminates
the tape record.

Term ina tes the
current fie Id
if reached
before the
count in the
format statement runs out
and terminates
the tape record.

Other
Delimiters

If 80 columns
have been read,
the current fie Id
and card are
terminated as if
reading $.

None

Effect of Slash
in Format
Statement 3

Causes the
next requested
field to be
taken from the
next card.

Causes the
None
next field requested to be
taken from i nformation after
the next carriage return on
the pa per ta pe •

Causes the
next fie Id requested to be
taken from the
next tape
record.

Causes the
next field requested to be
taken from the
next tape
record.

Teletype

Magnetic Tape

DECtape

3 Successive slashes are ignored in all cases. This can be visual ized logically since the slash merely signifies that the current buffer is empty and does not cause the next record to be read. No implicit slashes
are assumed at the end of an input format statement; i. e., all characters appear as one long string, irrespective of the input device except where the slash is used expl icitl y.

In all cases the unit record consists of the characters requested between slashes in the output format statement or by the entire statement if no slashes are used. As noted above, the end of an output format statement is taken as an impl icit slash. The maximum record which can be requested in any case is 256-{N+ 1}
characters where N equals the number of fields desired. All requested characters above that figure are
lost. The following additional I imitations apply:
1. For the Iine printer, a request of more than 120 characters per un it record destroys
the program.
2. For the paper tape punch, a request of more than 72 characters per unit record produces a tape which cannot be read off-line. If that restriction is not applicable the
maximum size record (256-(N+ 1) characters} can be used.

3. For the Teletype, all characters requested after the 72nd characlrer per unit record
type over the 72nd character.
4. For magnetic and DECtape the maximum size record can be used. Magnetic tape
records always consist of 85 words packed 3 characters per word with the end of record
del im iter in the proper place. DECtape blocks always consist of 256 unpacked characters with the end of record delimiter in the proper place.
TAB LE 4
Line Printer

OUTPUT FORMAT

Paper Tape

Teletype

Magnetic Tape

DECtape

Field Delimiters
Generated

None

Place TAB
equivale,nt
code in record.

Place TAB
equivalent
code in record.

Cause of
Generated
Field Delimiter

None

End-of-c:urrent
field

End-of-current
field

Record
Delimiters
Generated

Spaces line
printer 1 line

Carriage
return (plus
line feed in
ASCII mode)

Carriage
returnline feed

Carriage return
equiva lent code

Carriage return
equivalent code

Effect of Slash
in Format
Statement

Output the
present contents of the
buffer, if any,
and always
generate the
end of record
indicator.

Output the
present contents of the
buJfer, if any,
and always
generate the
end of record
indicator.

Generah~ end
Generate end
of record indiof record indicator and write cator and write
record i nI bufrecord in buffer, if any.
fer, if any.
Will not wri te
Will not write
an empty record. an empty record.

Effect of
End of Format
Statement

Implicit
Slash

I/O Operations with Paper Tape and Keyboard
Use of FORTRAN with paper tape and a keyboard permits a relaxation of some of the constraints on input
formats for floating-point numbers. With paper tape or keyboard, an item of data being read can be delim ited by a tabluation of a carriage return-I ine feed combination (for keyboard), or a carriage return (for
paper tape), which overrides the field width allotted in the format specificaticm. The I imits on maximum

field widths still apply, however: 7 for integer fields and 31 for real number fields. The number of
characters in a field must be less than or equal to the width specified or the overflow will be considered
another field.
60

FORMAT (214, E9.2)

will accept input from a keyboard thus:
-20

176

+ 16742E13 )

(I ine feed-carriage return)

or analogous paper tape input.
Also when using the keyboard for input, incorrect characters can be erased by striking the blank key.
The blank key erases the last character; successive blanks erase the next previous character. Thus to
erase the last three characters, strike the blank key three times. However, no changes in data may be
made after typing a tab or carriage return since this processes the data.

I/O Operations with Magnetic Tape
There are two kinds of I/O operations with magnetic tape: those which perform data transfers and those
which do not.

Data Transfers
Data transfers are effected as described in the last section. The device number is made up of the tape
unit number (0-7) added to a control number to specify the direction of data transfer. A control number
of 100 indicates a read operation; a control number of 200 indicates a write operation. Although actual
read/write operations are performed ordinarily in low-density (200 bpi), high-density (556 bpi) may be.
forced by adding 10 to the unit number when forming the effective device number.
When reading records written by a FORTRAN program, the I/O lists for the two operations should correspond.
When writing, output information is stored internally until a slash is encountered in the output statement,
for exampl e:
WRITE 207, 37, «MATX(J, K), J==1,.5), K==1,5)
37

FORMAT (516/)

Since MATX has 25 elements and the FORMAT statement specifies 5 per record, there would be 5 physical
records on the output tape corresponding to the array, MATX. The programmer must be careful when
manipulating tapes to keep track of their contents.

The upper limit to one physical record is 256 characters. A practical way tel avoid specifying oversized
records is to keep the product of items-per-record and field-width-plus-one less than 256.
In the example given, 5 items are processed before the slash i; encountered; hence, there are 5 items per
record and the field width of 6 plus 1 is 7; hence 36 characters per physical record (one character marks
the end of record). The character added to field width is an item separator.
The entire array matrix could be forced into one physical (and logical) record by the following:
37

FORMAT (1516, 1016/)

(note the upper I im it of 15 on the repetition count)

since 15 x 7 plus 10 x 7= 175 characters, well within the limit of 256.

If the output given in the example is to be read by a FORTRAN program, the following should be noted:
READ 107, 45, «MATX(J, K), J=l, 5)K==1, 5)
The READ statement causes the next physical record from tape unit 7 to be rE!ad into core. Should all
items be used from this record before the I/O I ist is exhausted, the next physical record automatically is
read from tape unit 7 until the list is exhausted. Therefore the correspondence of FORMAT statement
45 to FORMAT statement 37 is not critical.
Binary records (maximum length = 256 words) may be written or read by omitting the FORMAT statement
number in a WRITE or READ statement.

Non-Data Transfers
In addition to read and write, the following operations have been assigned control numbers:
Operation

Number

rewind
write end-of-file
backspace one record
backspace one file
skip one file (forward)
skip one record (forwcJrd)
unassigned

300
400
500
600
700
800
900
For example:
READ 302
WRITE 302

Rewi nd the tape on un it 2.

WRITE 402

Write end-of-file on unit 2.

Note that control operations require neither FORMAT statement number nor data list.

In addition, since

the device number determines the operation, it makes no difference whether READ or WRITE is used.
When writing end-of-file one could say, READ 402, although WRITE 402 is more readily understood. The
function of READ and WRITE in control operations is to transfer control to that portion of the object-time
system which processes device numbers.
There are two other characteristics of normal magnetic tape usage which have been provided for in the
FORTRAN system: recording sense level and IBM compatible BCD.

Recording Sense Level
Where appl icable (Type 521 and 522 Controls), tape sense level is normally set to high (AC bit 7 = 0 in
the control command). To set sense level low, the following statement should occur in the FORTRAN
program:
ISVL=l
where the normal value for ISVL is zero.

ISVL is the name of an internal location in the object-time

system.

IBM Compatible BCD
Records are ordinarily written in FIODEC codes. To write IBM compatible BCD codes, the following
statement should occur in the FORTRAN program:
IBM=16
where the normal value for IBM is zero.

IBM is the name of an internal location in the object-time system.

Note, however, that every tape record contains a BCD code 13 to del imit fields and a BCD code 14 to de-

I imit the logical record since the physical record length actually written is fixed at the maximum.

I/O Operation with DECtape
The device number for data transfers to or from DECtape is formed by designating the operation and tape
unit number in the following format:
COO U
where
C

is the desired operation (see below)

are always O's

is the DECtape unit number (1-8).

Operation codes:

1. Read
2. Write
3. Rewind
4. Write end-of-file
5. Backspace one record
6. Backspace one file
7. Skip forward one file
8. Sk i p forward one record

9. Unassigned
There are 576 fixed-length records (256 l8-bit words) on a reel of DECtape.
WRITE 2004, 100, A, B,CVAR
causes the three variables to be written on the next block of DECtape unit 4 according to FORMAT statement 100. Since record lengths and correspondence are fixed, the user must be careful when reading previously written records to have both the I/O I ist and FORMAT statements correspond. The most effic ient
use of DECtape storage dictates record lengths as close as possible to the maximum. The next block is
determined by the last operation on DECtape unit 4. The treatment is complet"ely analogous to IInext
record II on magnetic tape.

Binary Transfers
Another facility of PDP-7 magnetic tape operations with standard tape or DECtape is the ability to use
binary records. The number of items written per record will vary from 255 for fixed-point variables to
85 (255/3) for three-word floating-point variables. * To write or read a binary record, merely omit the
FORMAT statement number in the READ/WRITE command. For example:
READ 1004, A, B,CVAR
transfers the three variables from the next block on DECtape un it 4 into core CIS binary words.

*One word of each record's 256-word capacity serves as word counter of binary words entered in the record.
42

CHAPTER 5
SUBPROGRAMS:

FUNCTIONS AND

SUBROUTINES

The programmer may employ separate subprograms to perform a sequence of operations required in the
solution of the problem or to evaluate functions.

For example, whenever a function occurs in an arith-

metic expression, a subprogram is called into operation to evaluate the function using as data the
arguments provided. The resulting single value is then returned to be used in the computation of the expression in which the function appears. A second type of subprogram, the subroutine, is used when a
sequence of statements is used repeatedly or when it is necessary to generate more than one result (a matrix
operation, for example).
Since a subprogram is a separate program, communication with the main program must be establishedi that
is, an entry to the subprogram from the main program and an exit from the subprogram back to the main
program must be provided.

In the case of a function, entry is effected by the use of the function name

in an arithmetic expression. In the case of a subroutine, entry is effected by the CALL statement. The
RETURN statement provides an exit from both types of subprograms. A subprogram cannot come to a fu II
stop (though subroutines may include pauses) but must always return control to the colling program.

FUNCTIONS
In addition to the library functions supplied with FORTRAN, the user can write his own as needed.

The

writing of a function subprogram follows the rules for writing any sort of program, in that there must be
a title, a body, and an END statement. In addition, two special statements are required: FUNCTiON
definition and RETURN.

The FUNCTION Definition Statement
The FUNCTION definition statement identifies the subprogram and has the following form:
FUNCTION f (d l' d , d , ••• , d )
n
2
3
where f is the name of the function and d is a dummy name which represents the main program arguments
of the function. The function and dummy names follow the rules given for variables in Chapter 1: they
are restricted to the same character set, the first character must be alphabetic, and only the first six
characters are signi ficant. A main program argument can be a constant, a variable, or any legitimate
arithmetic expression.

It may itself include functions.

subprogram.

At least one argument is required with a function

Because a function is an element of an arithmetic expression, it must always return a value to the main
computation. To do this, there must be at least one arithmetic statement in the function subprogram, in
which the function name appears as the left-hand variable. This also defines the mode of the return value.
A function returns an integer-value if its name is defined as an integer variable, or a real-value if its
name is defined as a real variable. Exceptions to this rule are: 1) a function whose name begins with the
letter X is integer valued; 2) if a function name does not begin with X but ends with F, the function returns a real value. A function name cannot represent an array. STOP or PAUSE cannot be used in a
function.

RETURN Statements
The statement
RETURN
terminates the subprogram (function or subroutine) and transfers control to the calling program. There may
be more than one RETURN statement in a subprogram, corresponding to alterncJtive exits. Figure 19
illustrates the writing of a function subprogram which calculates the factorial of an integer ~:
n! = 2·3·4· •.• (n-2) (n-1) (n)
..

FACTORIAL CALCULATOR
FUNCTION NFACT (N)
NFACT = 1
DO 10 J=l, N
10 NFACT = NFACT * J
RETURN
END
Figure 19

Function Subprogram

In Figure 19, the name NFACT specifies an integer-valued function. The dummy name N denotes an integer argument. The body of the subprogram is a loop which calculates the falctorial. Statement 10 provides for the value to be returned, since the function name appears as a lefthcmd variable. Finally, the
RETURN statement transfers control to the calling program.

Use of Functions
Dummy names do not have to agree in mode with the function name or with eaich other. They must agree,
however, with the mode (integer, floating two-or three-word) of cot'respondinB arguments in the calling
program. For example, the factorial function above may be called this way (the dots represent parts of
an arithmetic statement):

•••. + NFACT(15)/ ••••
but not this way:

•... + NFACT{15.0)/ •..•
because the argument is not an integer.
Library functions which require real arguments such as SQRTF I COSF I are treated as floating point
variables in arithmetic expressions. No diagnostic check occurs during compilation to insure that the
arguments specified by the programmer are in fact real. For example:
A=SQRTF(I* K 2.2)
compi les correctly since the real nature of the exponent forces the entire parenthesis to be real.
However I
A=SQRTF(I* K/2)
must be wri tten as
A=SQRTF{T=I*K/2)
or some equivalent form if correct compi lation is expected.

Library Functions
Several common functions are provided with the FORTRAN system to save the programmer the necessity
of writing them. These library functions are named according to the following conventions:
1. Every library functions name ends with the letter F.
2. A function whose name begins with the letter X is integer-valued; otherwise it is
rea I-va Iued •
Library functions may be used by the programmer without any special preparation; they are placed in
memory from a library tape which is read prior to run time.
The library functions are:

Function Name

Operation Performed

SQRTF{A)
SINF{A)
COSF{A)
ATANF{A)
LOGF{A)

square root: v..;asin a (argument in radians)
cos a (argument in radians)
arc tan a
log a
e

Function Name

Operation Performed

CLOGF(A)
EXPF(A)
ABSF{A)
XABSF{N)

10910 a
ea
absolute value: lal
absolute value (integer):

In I

XABSF is the only integer-valued library function.

SUBROUTINES
It is often desirable to write whole procedures, not as functions (which can return only a single qUal_til'y)
but as complete subprograms which compute multiple -quantities for use by the main program. Such a suh-·
program is called a subroutine. Its definition statement is:
SUBROUTINE s (d , d , d ,·· .,d )
1 2
3
n
where s is the subroutine name, and d. are dummy arguments.
I

Like a function subprogram, a subroutine must have at least one RETURN statement. Unlike Ll ftHtcticm 1
however, a subroutine does not directly return a value to the calling program; instead results are stc,"ed
in locations designated by the main program, where they are available to the main program. A suLrolJhd~
name differs from a function name in that it may not appear as the left-hand v(lriable in an arithnleti"c
statement of the subprogram. A subroutine differs further from a function in that no arguments or.:; requii"eO
When arguments are present, they obey the same rules as those for functions wIth regard to mode.

The CALL Statement
To call a subroutine into operation, the following statement is used:
CALL s (a , a , a , ••• ,an)
1 2
3
where s is the subroutine name, and a. are arguments, if any.
I

The argument list of the CALL statement must be simi lar to the argument list in the subroutine.
The factorial calculator written as a function in Figure 19 may be written as a subroutine (15 ShOV';'.II(,
Figure 20. In this example, the main calculation is the same as before, but to make the result ':':I~iiilt,.,kde
to the calling program, another argument has been provided. If a program were to use this stJbrOljtiL"~ E.
calculate, for instance, the factorial of an integer variable K, the following statement might be IJSf:Ji~
CALL FACT (K, KPROD)

FACTORIAL CALCULATOR
SUBROUTINE FACT (N,NPROD)
NPROD=l
DO 10 J=l,N
10
NPROD = NPROD * J
RETURN
END
Figure 20

Example of Factorial Calculator

The value of the resulting product, assigned the dummy name NPROD in the subroutine, is given to the
variable KPROD in the calling program.

Common Storage
As Figure 20 shows, information can be transmitted between a calling program and a subprogram via the
argument list. Information can also be passed between programs through a special section of memory set
aside as common data storage. Space in this area is assi gned by the following specification statement:
COMMON vl, v2, v3, ••• ,vn
where each v represents a variable name, either simple or subscripted. Each simple variable is assigned
a location (or group of locations, depending on the storage mode) beginning at the end of avai lable
memory and working backward. Arrays are assigned enough locations to store the maximum number of
elements, as indicated by the DIMENSION statement. For example, if an integer array which appears
in a DIMENSION statement
DIMENSION MATRIX (20, 40)
also appears in a COMMON statement
COMMON MATRIX
there wi II be 20 x 40 == 800 locations set aside in common storage.
Programs which have common data must each have a COMMON statement in which the variables are assigned in correct order and storage mode, although the names do not have to be identical from program to
program. For example, two programs could share three variables if one program contained the statement
COMMON VARL, INDEX, AVAL
and the second program contained the statement
COMMON VARX, ITEST, AR GL
The first program uses the name VAR L, and the second V ARX, but both names refer to the same quanti ty.
Likewise, INDEX and ITEST are corresponding names, and so on down the line of variables.

Array Names Used In Subroutines
Array names may be transmitted between a cCllling program and a subroutine either as arguments or as
variables in common storage. The two methods require different treatments.
1. If an array is placed in common, it must be dimensioned in both programs and must
appear in a COMMON statement in both programs. The names need not be the same
but they must correspond in number and order in the COMMON statements. For example,

if an array appears in the calling program as follows:

DIMENSION ARRAY (lO, 10, 30)
COMMON VAR1, VAR2, ARRAY, IVAR

and is referred to in a subroutine by the name ARR2, this name must appear in the
subroutine in statements such as these:

DIMENSION ARR2 (10, 10, 30)
COMMON Xl, X2, ARR2

Here, the array name appears in the common list, following two real variables just
as the corresponding name does in the calling program.

MATRIX MULTIPLICATION SUBROUTINE
SUBROUTINE MATMUL (ID, JD, KD)
DIMENSION DA(10, 10), DB(10,10), DC(10, 10)
COMMON DC, DA, DB
DO 10 1=1, 10
DO 10 J=l, 10
10
DC(I, J)=O
DO 20 J=l, JD
DO 20 1=1, ID
DO 20 K=l, KD
20
DC(I, J)=DC(I, J) + DA(I, K) * DB(K, J)
RETURN
END
Figure 21

Matrix Multiplication Subroutine

In Fi gure 21, the three arrays necessary for the ca Iculation are placed in common. A
main program using this subroutine to multiply matrices of dimensions 5 x 10 and 10 x 7,
respectively, must contain statements such as the following:
DIMENSION AMTX(10, 10), BMTX(10, 10), CMTX(10, 10)
COMMON CMTX, AMTX, BMTX
CALL MATMUL (5,7,10)

2. If array names are to be transmitted as arguments, they must appear, unsubscripted,
in a DIMENSION statement in the subroutine. For example, the names of the matrices
required by the subroutine of Figure 21 could be used as arguments in this manner:
MATRIX MULTIPLICATION SUBROUTINE
SUBROUTINE MATMUL (lD, JD, KD, DA, DB, DC)
DIMENSION DA, DB, DC

END
The calling program could then have statements as follows:

DIMENSION AMTX (10, 10), BMTX (10, 10), CMTX (10, 10)

CALL MATMUL (5,7,10,AMTX, BMTX,CMTX)
Note that the array names appear without subscripts in the subroutine call also.

MACHINE LANGUAGE CODING IN A FORTRAN CONTEXT
Since the symbolic output of the compi ler is in the language of the assembler, fami liarity with that
language is basic to a thorough understanding of the topics discussed. Information on the assembler
language can be obtained from the PDP-7 Symbolic Assembler (Digital-7-3-S) and the PDP-7 Users
Handbook (F-75).

Handling of S Coding
As mentioned in Chapter 1, whenever the letter S (for symbolic) appears in the identification field, the
remainder of the line is transferred to the object program exactly as written. No error diagnosis is made
for an S-coded line. Unless the programmer is absolutely certain that he can omit them in safety, all
S coding should be bracketed (preceded and followed) by CONTINUE statements. Example:

READ 402
CONTINUE
S
LAS
SAND {7
S DAC J.
CONTINUE

Compi ler Generated Codi ng
The FORTRAN compiler generates an object program of symbolic machine instructions and pseudoinstructions from the FORTRAN statements it reads. In general, each statemEmt is processed individually
without reference to previous or subsequent statements; as a consequence, errors such as the duplication
of statement numbers are not detected by the diagnost-ic routines of the compi ler. Coding to test the
iteration variable of a DO loop is not generclted unti I after the last statemen1' in the DO loop.

Symbolic Conventions
To avoid conflicts with symbols which appear in the FORTRAN source program and symbols which appear
in the assembler permanent symbol table (machine language instructions and clssembly pseudo instructions),
or symbols which reference permanent locations in the FORTRAN object time system, special conventions
are established:

1. Symbols which appear in the FORTRAN source program and whic:h are five characters
or less are modified by appending the period (.) character.
2. Statement numbers are transformed into symbols by prefixing the period (.) character
to the statement numbers.
3. All symbols generated interna lIy by FORTRAN are four character symbols: the
period (.) character followed by three letters.
The period (.) character is not a permissible character for symbols which
appear in FORTRAN source programs. It is a permissible character for symbols in the object program as input to the assembler. A consequence is that
FORTRAN source program symbols (names) and the symbols whic:h are part of
the compiled object program ordinarily differ. For example:

1=2
genera tes the code
LAC {2
DAC I.
hence the variable name I must be referenced as I. if it occurs in a line of
S coding.

The conventions established for symbols insure that all symbols which appear in the FORTRAN object
program contain a period except those which are machine language instructions, mnemonics, assembler
pseudo instructions, FORTRAN object-time system references or six-character symbols from the source
program. To avoid conflicts, the following six-character symbols should not appear in the FORTRAN
source program:
DECIMA
ANALEX
NOSYMB
EXTERN
EXPUNG
FIODEC
NOINPU
NINDIG

VARIAB
LlBFRM
PUNDEF
TELETY
SYMBOL
INTERN
NARITH
LOGCOM

SECPRG
MODSET
MODRES
EFMTEM
EXTADD
EARITH
SARITH
SIXDIG

Floating Point Commands
Instructions generated by the FORTRAN compi ler may use fixed- or floating-point operands. Standard
machine instructions, i.e., directly executable instructions, are generated when the operands are fixed
point. When the operands are floating point (rea!), the instructions generated must be interpreted since
the PDP-7 does not have such instructions in its instruction set.
The floating-point interpreting program is an integral part of the FORTRAN object-time system. It is
entered by the pseudo instruction EFM (enter floating mode) which initializes the interpretive program
counter. Instructions are interpreted and executed sequentially until a transfer of program control (subprogram call) or the pseudo instruction LFM (leave floating mode) is encountered. The compiler generates
an E FM or LFM for each executab Ie statement number to insure that a II i nterna I program transfers are i tl
the proper arithmetic mode. EFM's or LFM's are also generated whenever they are needed; example:

I =1
A=1.
When the instruction sequence is in floating mode, the following mnemonics, which are the same as the
standard PDP-7 machine instruction mnemonics, are interpreted as floating mode commands:
LAC
ADD
DAC
JMP
JMS

load floati ng accumu lator
floating add
deposit floating accumulator
floating imp
floating ims

In addition, the following mnemonics are used only in the floating interpretive system:
FCS
FSB

floating clear and subtract
floati ng subtract

floating multiply
floating divide
floating compare accumulator to storage

FMP
FDV
CAS
Two instructions which may be generated are::
FXA

fix the floating accumulator and
leave floating mode

FLO

float the fixed accumulator cmd
enter floating mode

Notice that FXA carries an implicit LFM and that FLO carries an implicit EFM.
CAL instructions are handled by a program in the object-time system called the CAL Handler (see
DEC-7-46-U). The CAL Handler saves all relevant information in a push-down stack, and the CAL
executes in fixed point.

Subprogram Linking

Implicit Subprogram Calls
An implicit subprogram call occurs when implementation of a feature included in the source language
requires an internal subsection of the object time system or use of the FORTRAN library exponential
function. An example of the latter case is the generation of a JMS XPN fixE~d-point operand or JMS EXP
floating-point operand in response to the appearance of the exponential opertJtor (t).
The appearance of an array name in a DIMENSION statement generates an implicit subprogram call of
the following form:
NAME,

JMS CALSB
LAW TWO
LAW THREE
LAW INTDIM
.GS

The example above supposes a three-dimensicmal array. CALSB is the name of the subscript calculating
section of the ob ject-time system. TWO and THREE stand for the actua I va IUles of the second and third
bounds. The initial bound is not needed for subscript calculation but generat,es storage allocation for the
array. INTDIM will be 1, 2, or 3 for, respectively, fixed point, 2-word or 3-word floating point. It
specifies the number of memory locations required for each array element. The symbol • GS stands for

the generated symbol which actua lIy defines the address of the array.

NAME is the actual array name.

(Refer to Construction of Dimensioned Variables, page 57.) Four additional implicit subprograms which
may be called in a FORTRAN object program are:
GOTO
CALST
GTARG

computed go to
to initialize the CAL Handler
to get arguments of a subroutine
or function
to initialize 2-word floating point
data storage

SET2W

Explicit Subprogram Calls - Explicit subprogram calls are generated by the following features of the
FORTRAN language:
1. A library function reference
2. A CALL statement (subroutine)
3. Reference to a subscripted variable
4. An I/O control statement
The code generated by items 1, 2, and 3 conforms to a general form; the code generated by item 4 is
slightly different and is discussed under I/O statements.
A normal subprogram call generates
CAL A
where A is the name of the subprogram. If the subprogram has arguments (a function must have arguments;
a subroutine mayor may not have arguments; the arguments of a subscripted variable reference are its
subscripts), the CAL instruction is followed by code of the following form:
ARz • GS
where ARz is ARX for fixed point mode or ARF for floating mode. The argument name of • GS is the
memory location (if floating point, the first of two or three words).
When passing an array name to a subroutine, subscripts are omitted and the array name appears as an
argument:
ARz NAME.
When CAL is processed, the CAL Handler saves the mode (fixed or floating point), the corresponding
accumu lator, and the return address. It then transfers control to the address indicated in the CAL instruction. Control is returned to the calling program by means of the return portion of the CAL Handler
which restores the accumulator and mode and transfers control back to the instruction following the
calling sequence.

Function Linkage
A function is always used in an arithmetic expression. It acts like a variable which is equal to the value
of the function with the given arguments. 'Nhen the function name occurs to, the left of the equal sign
(in the body of the function) the value of the arithmetic expression to the right of the equal sign is interpreted by the compiler to be the value of the function.
This value is placed in an internal location named RES, and when the return statement is encountered,
the address RES returns to the return portion of the CAL Handler. This address is placed in a location
called TEMAD (temporary address storage) internal to the object-time system, and the value of the function
is then accessed indirectly through this locaf'ion. Should another function cell I occur before this address
is referenced by the calling program, the compiler generates <;1 code to retrieve the previously calculated
function value. Dimensioned variable references are effected through location TEMAD as though they
were functions.
For example, the statement
100

A=SIN (B)+C

generates the fol lowing object code:
.100,

EXTERNAL SIN.
CAL SIN.
ARF B.
LAC I TEMAD
ADD C.
DACA.

A function definition statement:
FUNCTION FNAME (A,B,I)
generates the following code:
FNAME .,

A.,
B. ,
I.,

INTER NAL FNAME.
JMS GTARG
JMP .GS

o
o
o

• GS,
where • GS is a symbo I generated by the FORTRAN compi ler. The GTAR G r()uti ne, when executed,
wou Id place the addresses of the dummy arguments A., B., and I. in the loccltions reserved for them.
Note the use of pseudo instructions EXTERNAL and I NTERNAL. When EXTERNAL is encountered by the
assembler, it generates information to the loader requiring that all references to the accompanying symbol

(or symbols since more than one may occur with EXTERNAL) be saved by linking unti I the occurrence of
a definition of that symbol; this is signaled by the occurrence of INTERNAL and one accompanying symbol (only one symbol may occur with INTERNAL).
For example, consider a factorial calculator function which returns a floating-point value.
FACTORIAL CALCULATOR
FUNCTION FACT(N)
FACT=l
DO 10 J=l ,N
10
FACT=FACT*J
RETURN
END
The compiler generates the following code:
FACTORIAL CALCULATOR
DECIMA*
FACT. ,

N.,

FIODECt
INTERNAL FACT.
JMS GTARG
JMP .AAA

/GTARG PICKS UP ARZ ADDRESS
lAND PLACES IT IN N .

•AAA,
LAC (l
FLO
DAC RES
LFM
LAC (1
DAC J .
•AAB,
. 10,

LFM
LAC J.
FLO
FMP RES
DAC RES

IFLOATING POINT RESULT STORED
/IN RES

LFM
LAC J.
ADD (l
DAC J.
CMA
ADD I N.
ADD (l
SMA
*DECIMA indicates that all subsequent numbers will be interpreted in decimal radix rather than in octal
radix.
tFIODEC indicates that all character translations are to FIODEC code; i.e., H-format in format statements.

JMP .AAB
LAW RES
RETUR
HLT

/ ADDRESS OF RES IS RETURNED

TEM,
TEM+O/
START
Subroutine Linkage
The code generated by the control word SUBROUTI NE is very simi lar. Since a subroutine need not return
a value, the user must establish storage for results either by passing the argument{s) to the subroutine in
the call statement or by establishing them in a common statement.
The following is a possible version of the factorial calculator written as a subroutine:
FACTORIAL CALCULATOR
SUBROUTINE FACT (N,R)
R=l
DO lOJ=l,N
10
R=R*J
RETURN
END
where R contains factorial N in floating point.
The compi ler generates the following code:
FACTORIAL CALCULATOR
DECIMA
FIODEC
INTERNAL FACT.
FACT. ,
JMS GTARG
JMP .AAA
N. ,

R. ,
.AAA

LAC (l
FLO
DAC I R.
LFM
LAC (l
DAC J .
•AAB,
• 10,

LFM
LAC J.
FLO
FMP I R.
DAC I R.
LFM

LAC J.
ADD (l
DAC J.
CMA
ADD IN.
ADD (l
SMA
JMP .AAB
RETUR
HLT
TEM,
TEM+O/
START

Construction of Dimensioned Variables
When dimensioned variable references occur in the FORTRAN source language, the code generated is
very similar to that generated by a function call. A DIMENSION statement generates an internal function
which has the name of the variable. When the function is called, its value is the address of the element
of the array specified by the va lues of the subscripts at the time of the call, and that address is placed in
location TEMAD. For example, the statement

Z=A(I)
generates the object code
CAL A.
ARX I.
EFM
LAC I TEMAD
DAC Z.
On the other hand, the statement

A(I)=Z
generates the ob ject code
CALA.
ARX I.
EFM
LAC Z.
DAC I TEMAD

Allocation of Array Storage and the Subscript Calculator
A simple example of array storage allocation is the two-dimensional array A(2,2). A two-dimensional
array is stored sequentially by rows indexed by columns (in this case):
A(l,1)
A(1 ,2)

A(2, 1)
A(2,2)
or in general, an n-dimensional array is stored with the first dimension varying least. The standard objecttime system subscript calculation program accommodates up to four dimensions.. Higher dimensions may be
provided for upon request.

I/O Statements
An I/O statement of the general form
RW n,m,a,b,i
generates the following code
RW

JMS .IOX
N
FOR .M
ARF A.
ARF B.
ARX I.
ENOIO
where RW is READ or WRITE, .IOX designates the corresponding I/O device IProcessor.

X may be 1-9,

.101 IV keyboard input, .107 corresponds to ASCII Iine printer output etc.j devices 8 and 9 are presently
unassigned.

Normal tape

.1057 A, OECtape IV .1 OOEC. (N is the device number (n)), and the next

location designates the address (. M) of the accompanying format statement. Succeeding entries contain
the addresses (A., B., I.) of the referenced variables (a, b, c). Code genercJted by an array transfer
expression is fairly complicated but simi lar f'o the code generated by an explicit DO loop. ENDIO is
the address of that section of the object-time system which terminates I/O operations.

Note that Hollerith

text is stored with the object program code sequence generated by the corresponding FORMAT statement.

SECTION 2
OPERATING PROCEDURES
DIAGNOSTICS
AND
ERROR MESSAGES

CHAPTER 6
OPERATING

PROCEDURES

This chapter details standard operating procedures for the PDP-7 FORTRAN system. PDP-7 FORTRAN is
written for a machine having SK of memory but significantly different hardware configurations; one an
exclusively paper-tape configuration and the other a configuration which includes minimally two tape
units (either normal magnetic tape or a dual DECtape unit). In an SK system approximately 460010 locations are available for program and data.
The principal subsections of the FORTRAN system for paper tape are:
Compiler
Assembler
Operating System
Library
The compiler accepts input in the FORTRAN language and produces an object program output in computer
source language (see page 55) acceptable to the Assembler. The Assembler accepts the compi ler output
and produces a binary relocatable version of the program and a binary version of the Linking Loader. When
the user is ready to run the program, he loads his main program and any subprograms followed by any builtin functions called -from the library. Once the total program is in memory, he loads the operating system
and executes his program. The operating system contains an interpreter for floating-point arithmetic, an
interpreter for FORMAT statements, red tape routines such as fix a floating number and vice versa, and
the I/O routines. The operating system must be in memory when a FORTRAN program is executed.

PROCEDURE FOR USING FORTRAN WITH A PDP-7 PAPER TAPE SYSTEM
The Bootstrap loader with starting address 17770 (for SK machines) is ca lied the readin mode, or RIM,
S
Loader. Pressing the START switch on the console with 17770 in the ADDRESS switches is referred to
S
as RIM start.
Step 1

Prepare programs to be compiled in accordance with the conventions described
in the precedi ng section. Each program or subprogram on paper tape must be
followed by the three-character sequence
carriage return-I ine feed
carriage return-I ine feed
form feed
61

Step 2

Place the paper tape labeled FORTRAN Compiler in reader, set ADDRESS switches
to 177708' and press START.

Step 3

Position ACCUMULATOR switches 9 and 10 as follows to indicate tape formats
for, respectively, the intermediate object program (assembller source) tape and
the compiler source tape: AC9 {intermediate object tape} .• up for ASCII, down
for FIODEC. AC10 (compiler source) - up for ASCII, down for FIODEC. Turn
on the tape punch. Place the program tape to be compiled in the reader and
press CONTI NUE. FORTRAN punches out the intermediah~ object program tape.

Step 4

If other programs are to be compiled, repeat Step 3. If an accidental error
occurs at any time, such as the punch running out of paper tape before compilation is completed, the compilation procedure may be rE~started by replacing
the source tape in the reader, placing 228 in the ADDRESS switch, and depressing START.

Step 5

If an error occurs in the source language, the compiler typ1es a three-letter plus
two-digit code on the teleprinter followed by the current ('last encountered)
statement number. The compiler also prints the offending line with the errant
character flagged by a I ine feed. See Chapter 8 for the assoc iated error conditions. As a rule, a source language error prevents proper execution of the
compiled program. The error must be corrected and the prc)gram compiled again.
However, compilation should be completed to uncover all lerrors in the same
program.

Step 6

When all necessary compilations have been successfully completed, remove the
output tape(s} from the punch.

Step 7

Place the paper tape labeled FORTRAN Assembler in the reader, set ADDRESS
switches to 177708' and depress START. Set ACCUMULATOR switch 10 as
follows: up if assembler source tape is ASCII, down if it is, FIODEC.

NOTE: The setting of AC1
above.

Step 8

should be identical to the setting of AC9 in Step 3,

Place the first program to be assembled in the reader. If several programs were
compiled together they will be separated from each other by a short length of

blank tape. The punch must be on. Depress CONTI NUE. The Assembler
punches a partial binary output, displaying all ACCUMULATOR lights ON
when it is finished. Should an error occur during the assembly procedure, the
Assembler prints a message on the teleprinter. For a summary see Chapter 8
An error printed by the Assembler usually is the result of an original program
not detected by FORTRAN.
Step 9

Depress CONTI NUE to finish punching the binary output. Undefined symbols
in the source program (symbols which never appear on the left-hand side of an
arithmetic statement, in an input statement or as the argument of a subroutine
call, or in aCOMMON statement) are printed with a relative location automatically assigned by the Assembler. Any statement number which is referred
to but never used as a statement label will be printed also. When finished, all
ACCUMULATOR lights will again be ON. If an error occurs during this step,
repeat the assembly process (Step 8) before accepting the error diagnosis.

Step 10 If a printout of the relative locations of program symbols is desired, put the
ri ghtmost switch of the ACCUMULATOR switches (bit 17) to the up position
and press CONTINUE. If the printout is not desired, leave the switch in the
down position and press CONTI NUE to restore the Assembler for the next
assembly. The ACCUMULATOR lights will all be OFF at this stage.
Step 11

If more programs are to be assembled, place the next tape in the reader and
return to Step 8. If severa I programs were compi led together, be sure that
the blank tape area separating them is under the reader light before continuing.
Since the Assembler uses a buffered loader, the end of one program and the
beginning of the next program are likely to be read into the same buffer. It is
usually necessary to withdraw a portion of tape which has already been read in
order to start reading at the beginning of the second and succeeding programs on
the same paper tape.

Step 12 Remove the assembled programs from the punch. Each program will have its
title punched in readable format at the beginning. Since the FORTRAN
Assembler is a one-pass assembler, the title wi II be the last item punched on
the tape.

NOTE: The following steps describe the loading process. After each tape is
loaded into memory the ACCUMULATOR I ights will display the first memory
address not used.

Step 13 Load the main program through R1M start.

It is important that the main program

be loaded first since the Linking Loader is punched on the main program tape
only. The loader is a lengthy strip of tape immediately following the title
with the eighth hole punched in every line. The RIM Loadler, through use of
a Bootstrap Routine, loads the Linking Loader which, in turn, loads the main
program.
Step 14 Place any subprograms in the reader {readable title is always in the leader},
and load through RIM start. The Linking Loader will handlle the problems of

I inking between programs. The first instruction executed by the RIM Loader
is a jump to an entry in the Linking Loader.
Step 15 To obtain a printout of the absolute locations in memory of subprogram symbols
and/or to determine if library subroutines are required, place 58 in the
ADDRESS switches and depress START.

If a subroutine or I ibrary function has

been called but not yet loaded, its symbol will be preceded on the line by a
minus sign followed by the address of the first reference to this symbol.

further subprograms are needed, they should be loaded as in Step 14 above.
Step 16 Load the LIBRARY I/O tape; i. e., place the I ibrary tape in the reader, set
ADDRESS switches to 6 , and depress START. If any subro·utine names are
8
preceded by 11_ _ ,11 load the 6DD or 9DD LIBRARY tape,; i.e., set ADDRESS
switches to 6 and depress START. When all called functions have been loaded,
8
the loader halts, perhaps part way through the I ibrary tape.
Step 17 Load the tape labeled IIFORTRAN Operating System II through RIM start.

paper tape input to the FORTRAN program is used, this sh()uld be ready in the
reader.
Step 18 Place 228 in the ADDRESS switches and depress START to execute the program.

NOTE: The Linking Loader does not detect when the user has loaded a program
over common storage {assigned backward from the last address in memory}. To
guarantee an overlay has not occurred, the first program address not used as

indicated in the AC I ights after loading should always be equal to or smaller
than the lowest address in common storage necessary to store the arrays and
common variables used in the program.

General Notes:

1. The first word of every FORTRAN program (main or subroutine) has a relative address
of 1 ,
8
2. The initial relocation constant is 21 ,
8
3. After each program is loaded, the AC I ights display the address of the next free
location. This address is also the relocation of the next program to be loaded.
location is unused between programs.)

(One

CHAPTER 7
DIAGNOSTICS

The following diagnostics may be printed during compl iations followed by the offending statement with a
line feed after the last character processed.
two-digit number.

Each diagnostic is identified by a three-letter name, and a

For a" errors except those which indicate storage capacity exceeded, processing con-

tinues. The diagnostic error print (below) is followed by the current statement number.
As previously noted the occurrence of an error wi" necessitate correction of the error and recompilation.

Error
Name

Error
Number

Reason for Error

CONTROL STATEMENT

CON

Illegal control statement.

Upper case character in control statement.
COMMON STATEMENT

COM

III ega I entry in list.
2

Symbol appears twice in COMMON.
ASSIGN

ASG

N not a fixed-point number.

Number not followed by litO. II

No fixed-point variable.

Illegal format - variable.
SUBROUTINE AND FUNCTION

SUB

Name not a variable.

Dummy symbol not a variable.

Dummy symbol used twice.

DIM

DIMENSION
Array name not a variable.

Array dimensioned twice.

Dimension not a fixed-point number.

Error
Name

Error
Number

Reason for Error

DO STATEMENT

First two Ietters not do.

No statement number.

No end test value specified.

Too many characters.
ILLEGAL FORMAT

ILF

Nonstatement number at left margin.

Missing left parenthesis.

Missing right parenthesis.

Missing left parenthesis.

Missing right parenthesis.

Comma missing in goto.

Variable missing in arithmetic: statements.

Illegal device number in input or output statement.

III egal format in accept statement.

Extra right parenthesis.

Extra characters in statement"

Comma missing in repetitive element in I/O list.

Illegal format in I/O I ist element.

Illegal format statement number in an I/O statement.
ILLEGAL CHARACTER

ICH

III ega I character.

Illegal upper-case character.

No more characters after an illegal one.
Miscellaneous errors. Cannot proceed.

DIT

Logic error.

Wrong place in table.

Dispatch number too big.

Too many calls.

Illegal cal.

Too many ex its.

If any of the errors labeled DIT occurs, correct all other errors and recompile; if DIT
errors still occur, note any pertinent data and send to DEC Programming Group.

Error
Name

Error
Number

Reason for Error

UNSEEN FIXED POINT

UFX

Fixed-point number expected; punctuation
character or no character appeared.

Floating point quantity appeared where fixedpoint number expected.

Fixed-point number expected; decimal number
appeared.
FORMAT STATEMENT

FOR

Character missing.

Illegal format.

Characters missing.

III ega I contro I character.

Illegal punctuation.

Specification letter other than I,F,E,X,H.

N too large in H format
ILLEGAL FUNCTION USAGE

IFU

Function name on left side outside function
definition.
STORAGE CAPAC lTV EXCEEDED

SCE

Processing may not proceed.
Pol ish stack exhausted.

Table exceeded.

Symbol generator exhausted.

Table exceeded.

Statement too long.

Push down stack exceeded (too many nested do's).

CHAPTER
ERROR

MESSAGES (FORTRAN

ASSEMBLER)

The following error messages refer to the object program code generated by the compiler.

Familiarity

with this code is necessary for an understanding of this chapter. See the Assembler Program Description
(Digital-7-3-S) for details.
With the exception of SCE (storage capacity exceeded) and ILP (illegal parity), assembly continues after
the error message has been printed unless assembl ing a I ibrary tape. An error message may occur in one
of three formats.
Format A
ERROR PREVIOUS VALUE SYMBOL NEW VALUE
Format A indicates errors in the redefinition of symbols.

ERROR represents a three-letter code for the

particular error. Whether the symbol was redefined depends upon the particular error.
Error

Mean i ng

MDT

The symbol was redefined with a comma.

RSP

A permanent symbol was redefined.

RDA

An attempt to redefine a symbol was made.
The symbol was not redefined.

Format B
ERROR OCTAL ADDRESS SYMBOL IC ADDRESS
The general error message is printed in Format B.

It includes both the octal address and the symbol ic

address at which the error occurred.
Error

Mean i ng

IFP

Illegal format in parameter assignment.

IFC

Illegal format in a symbolic address tag.

IFQ

Illegal format in library list.

IFY

Illegal format in internal declaration.

IFZ

More than one symbol in internal declaration.

LlQ

Illegal term punctuation in library list.

Error

Mean i ng

MDT

Thf3 location counter and address disagree in an
address assignment.

TUA

Too many undefined symbols in a symbol ic address
tag.

IL F

III egal format in a pseudo-instructic:m.

LIT

Illegal terminator in a PUNDEF or IEXTERNAL list.

IFL

Illegal format in a PUNDEF or EXTIERNAL list.

I FS

"I egal format in a START.

IFI

Illegal format in an input pseudo-instruction.

SCE

Storage capacity exceeded.

INS

A nonsymbol appeared in a PUNDEF list.

IFX

External symbol preceeded external declaration.

Format C
ERROR OCTAL ADDRESS SYMBOLIC ADDRESS CAUSE
Format C is an expanded version of Format B. CAUSE is additional informaticm to help the programmer
ascertain the cause of the error.

For example, in the case of an error caused by an undefined symbol,

the symbol will be printed.
Error

Cause

Meaning

ILP

character

"legal parity (place correct character in ACS and press
CONTINUE). May also be caused by reading tape in
backward order.

UST

symbol

Undefined symbol in a START or PAUSE.

UAA

symbol

Undefined symbol in an absol ute address assignment.

UPA

symbol

Undefined symbol in a parameter as!;ignment.

ICH

character

" Iega I c haracte r .

SYS

symbol

Previously defined symbol in interncll declaration.

UPN

symbol

Undefined symbol in a punch pseudc~-instruction.

Undefined Symbol Assignment
At the end of assembly before the loader is punched, the undefined symbols and their definitions are
printed. Each undefined symbol used in a storage word wi" be defined as the address of a register at the
end of the program, and the definition printed.

If the symbol was not used in a storage word, the symbol

is printed and not defined. An example of the latter is a symbol which appears to the right in a parameter
assignment only.

APPENDIX 1
CHARACTER CODE EQUIVALENCES

The two text handl ing modes (A, H) use character code sets for which the octal equivalents differ in some
respects for the two formats.

Under A format, characters are stored in a 6-bit, 64-character code called

III ine printer FIODECII (PDP-7 Users Handbook, F-75, page 178). Under H format, characters are stored
in a code called flexowriter FIODEC, which includes a case shift, indicated by u in the table. The
upper case escape code is 74; the return code, 72.
When providing a dummy string of text for a READ Hollerith operation, the user must remember that the
code is compiled directly into the format control list. This requires that the number of core locations
occupied by the dummy text correspond exactly to the text read in at run time. Since th is may vary in
content, the following rules are necessary:
1. The dummy string and the input string must be the same length.
2. Corresponding characters in each string must agree in case; i.e., both the
characters in the dummy string and the character in the input string must be from the
set which is flagged by a u orboth be from the set which is not flagged.

NOTE: If a character equivalence is indicated by NA in the table, the character is not available for use in the indicated format. On the model 33, a
shift with the letters M, L, K produces the characters] , \ , [ respectively.

TABLE 5 CORE REPRESENTA nONS OF
THE ASCII CHARACTERS, A AND H FORMATSt
IAI

Character

ASCII

Space

240

Format

IHI

Format

241

242

243

244

0/0

245

40
NA

tThis table applies when typing a FORTRAN program either off-line or using the Symbolic Tape Editor.
73

TABLE 5 CORE REPRESENTATIONS OF
THE ASCII CHARACTERS, A AND H FORMATSt (continued)
IAI

IHI

Character

ASCII

246

247

250

251

252

253

254

255

256

257

260

261

262

263

264

265

266

267

270

271

272

273

274

275

276

277

300

301

302

303

304

Format

Format
NA

tThis table appl ies when typing a FORTRAN program either off-I ine or using "the Symbol ic Tape Editor.
74

TABLE 5 CORE REPRESENTATIONS OF
THE ASCII CHARACTERS, A AND H FORMATSt (continued)
IAI

IHI

Character

ASCII

305

306

307

310

311

312

313

314

315

316

317

320

321

302

323

324

325

326

327

330

331

332

[

333

334

]

335

336

337

tab

211

carriage return

215

Format

57
NA

tThis tabl e appl ies when typing a FORTRAN program either off-I ine or using the Symbol ic Tope Editor.

APPENDIX 2
USE OF EXTENDED MEMORY

The FORTRAN system operates autonomously within one 8K core bank. However, fac iI ities have been
provided to allow the accessing of data outside the operative memory bank, with the restrictions that all
such data must be stored as arrays and common storage may not be used.

For purposes of discussion, we

shall refer to data stored outside the operative core bank as being an extended array.

Such arrays must

be declared in a dimension statement before they are referenced, and the dimension statement must be
accompanied by an extend-mode statement which is analogous to a common statement with the exception
that its variable I ist must contain only the names of extended arrays.
One of the definitions assigned for the FORTRAN Assembler is XND which defines the top of storage for
extended arrays. The normal definition for XND is 37777 , the equivalent of an extra 8K core bank.
8
This definition may be changed at the discretion of the programmer either by changing the definition in
the assembler's permanent symbol table or by an S-coded parameter assignment in the FORTRAN program.
For example:
TITLE
SXND = OCTAL 27777 DEC IMAL
DIMENSION KV(25), PKV(25), VK(25, 25)
EXTEN D MODE KV, VK
will declare KV and VK (but not PKV) as extended arrays.
Since the FORTRAN system always enables extend mode (EEM) in the hardware sense, S-coded subroutines
must be carefully programmed when referencing indirect addresses since 15 bits will be interpreted rather
than the usual 13 (see PDP-7 Users Handbook, F-75, page 71).

APPENDIX 3
FORTRAN

SUMMARY DESCRIPTION

In the following description of the language used by the PDP-7 FORTRAN compiler, some fami! iarity with
existing FORTRAN dialects is assumed.

CHARACTER SET (ASCII)

I +

I · I

Basic:

A-Z

Special:

Space, tab, carriage return, dollar sign, parentheses, line feed, (form feed used with
paper tape)

0-9

PUNCHED PAPER TAPE CONVENTIONS
At most, one statement with two fields may occur per line.

Field one is delimited by the left-hand margin

and on the right by a tabulation; field two begins at the tabulation and Is terminated by a carriage returnI ine feed.

Legal Elements in Field One
Statement numbers.
Dollar sign ($) is the continuation character for FORTRAN statements which are too long for one physical
line.
S, the letter, causes the remainder of the I ine to be copied fnto the output program verbatim. This allows
machine language programming in the source language tape.
C, the letter, initiates a comment.

Field Two
Fie'd two constitutes the FORTRAN statement proper.

NUMBER REPRESENTATION
Fixed-point numbers are allocated one storage word only and appear as integers, n, where

o ~ I n I ~ 131071.
79

Floating-point numbers have two internal representations possible: a packed version with approximately
six-digit accuracy requiring two storage words; a!1d an unpacked version with approximately nine-digit
accuracy requiring three storage words.

Norrnal representation is three-word, with two-word representa-

tion available by definition.

LIBRARY FUNCTIONS
Functions presently in the library are: XABSF, ATANF, SINF, COSF, EXPF, LOGF, SQRTF, and the
variant CLOGF which returns the common log of its argument. The argument may be a simple variable,
an array element, or an arithmetic expression. A function may be used as are variables; all are floating
point except XABSF.

FORTRAN STATEMENTS
There are four basic categories of FORTRAN statements: arithmetic, control, specification, and input/
output. Arithmetic statements are of the form V = E where V is a variable and E a computable expression.
Control statements, such as IF, GOTO, DO, are those which (in general) direct program flow.

Specifi-

cation statements such as DIMENSION and SUBROUTINE supply information lro the compiler.

I/O state-

ments direct information transfers and are divided into two subcategories:

those which describe the

particular transfer desired (READ/WRITE), and those which describe the organization of the information
transferred (FORMAT).
Arithmetic Statements (V = E)
V must be a variable, either simple or subscripted (an array element). E cons,ists of terms connected by
operators, where legal terms are:
a constant
a simple variable
a subscripted variable
a function call
an arithmetic statement enclosed in parentheses
and the Iegal operators are:

plus
minus

divide

multiply
exponentiation

replacement

For example:

D (I, J, 3)= (A+ B)* (J=T+ 1.)/T

Use of Parentheses
Note the uses of parentheses in the example just given. They enclose the subscripts of the dimensioned
variable D; specify the concatenation of A, B (without the pair (A + B) the expression would mean
A + (B * J/T)); and del imit the internal arithmetic statement J = T + 1 •

Order of Computation
When a choice is possible, operations are performed in the following order:
expressions in parentheses
unary minus*
exponent iat ion
multipl ication and division
plus and minus
replacement (equal sign)

Modes
The modes within an arithmetic statement may be mixed floating point and fixed point. The expression
J = T + 1. could be safely written J = T + 1 without the (floating) decimal point.

If possible, combine

the fixed-point operands using fixed-point arithmetic; for example, in the statement:
A = B + (I + J + K)/2,
I, J, K is added in fixed point before the conversion to floating point occurs.

Control Statements

Available Statements
GOTO
ASSIGN
IF

*A unary minus is preceded by an operator and has only one operand; e.g., A = -A + (C * -D) - E is the
same as A = (-A) + (C * (-D)) - (E). The third minus is a proper (binary) minus.
81

DO
CONTINUE
CALL
RETURN
PAUSE
STOP

GOTO
Unconditional transfer
GOTO n: n is a statement number

Computer GOTO - GOTO (n 1, n2, n3, .. nn), I: transfer to statement nj where j is the value of the
fixed point variable I.

Assigned GOTO Type One - GOTO I (n1, n2, n3, ... nn): transfer to statement nj where nj was assigned
to I by an ASSIGN statement.

Assigned GOTO Type Two - GOTO I: where the value of I is the statement number last assigned to I by
an ASSIGN statement.

ASSIGN
ASSIGN n to i: n must be a statement number.

IF
IF (A) n 1, n2, n3: A may be a variable or an expression. n 1, n2, n3 are the numbers of statements to
which control will be transferred when the value of A is < 0, = 0, > 0, respectively.

DO
The general form of the DO statement is:
DO n I = m1, m2, m3
and it may be paraphrased as:

DO through statement n for I = m1; after statlement n is completed, in-

crement I by m3; if I is less than or equal to m2, repeat the sequence; if not, continue on in the program. II
An om itted increment (m3) will be taken to be 1 .

DO Loop Nesting - DO loops may appear within DO loops; however, the innermost DO must end on the
same statement (or one which occurs earlier) as that which terminates the next level (outer) DO loop.
Upon normal exit from a DO loop, the value of the DO variable (I) will be the one generated at the final
test, i. e., greater than m2.

CONTINUE Statements
Since a DO loop may not end on a statement which initiates a control transfer (such as an IF statement),
the CONTINUE statement has been provided. Though it does not cause instruction compilation by FORTRAN, it may be labeled with a statement number and used to terminate DO loops (q.v.).

It may be used

also as a dummy statement anywhere in the FORTRAN source program.

Subprogram CALLS
The CALL statement calls subroutines. The general forms are:
1. CALL NAME
2. CALL NAME (ARG1, ARG2, ..• ARGN)
where NAME is the name of the subroutine being called and the ARGi are the (variable) arguments of the
subroutine. The arguments may be arbitrary arithmetic expressions but must agree in type with those expected by the subroutine.

RETURN Statements
The RETURN statement has meaning only within a subroutine or function and indicates the point or points
at which control returns to the calling program. RETURN does not imply END.

PAUSE, STOP Statements
The general form of the PAUSE statement is:
PAUSE N
where N is an octal number which may be omitted. When the statement is encountered during the execution of a program the computer will halt, displaying N in the accumulator lights.

Depressing the CON-

TINUE switch on the console restarts the program. STOP is equivalent to PAUSE except that program
operation cannot be resumed.

mO·DDma

EQUIPMENT
CORPORATION

MAYNARD. MASSACHUSETTS

5598

PRINTED IN U.S.A. "

10-3/66