Digital PDFs

DEC-08-LFTNA-A-D

July 1973

183 pages

Original

6.5MB

Document:	8K Fortran SABR Assembler 197307
Order Number:	DEC-08-LFTNA-A-D
Revision:
Pages:	183
Original Filename:	http://bitsavers.org/pdf/dec/pdp8/fortran/DEC-08-LFTNA-A-D_8K_Fortran_SABR_Assembler_197307.pdf

OCR Text

mnmnomn

SK o

sabr assembler

digital equipment corporation

DEC-08-LFTNA-A-D

F 0 RT RA N

S AB R AS S E MB L E R

For additional copies, order No. DEC-08-LFTNA-A-D
from Software Distribution Center,· Digital Equipment
Corporation, Maynard, Mass.

digital equipment corporation · maynard. massachusetts

First Printing, July 1973

@ 1973, Digital Equipment Corp., Maynard, Mass.

The following a~e trademarks of Digital Equipment Corporation,
Maynard, Massachusett$:
CDP
COMPUTER LAB
COMTEX
COMSYST
DDT
DEC
DEC COMM
DECTAPE
DIBOL

DIGITAL
DNC
EDGRIN
EDU SYSTEM
FLIP CHIP
f OCAL
GLc~s

:to.Ac
'.IDACS
INDAC

KAlO

LAB-8
LAB-8/e
LAB-K
OMNIBUS
OS/8
PDP
PHA

PS/8
QUICKPOINT
RAD-8
RSTS
RSX
RTM
SABR
TYPESET 8
UNIBUS

PREFACE

The "HOW TO OBTAIN SOFTWARE INFORMATION" page, located at the back of
this document, explains the various services available to DIGITAL
software users.
The postage prepaid "READER'S COM!1ENTS" form on the last page of this
document requests the user's critical evaluation.
All comments
received are acknowledged and will be considered when subsequent
documents are prepared.
The software described in this document is furnished to the purchaser
under a license for use on a single computer system and can be copied
(with inclusion of DIGITAL's copyright notice) only for use in such
system, except as may otherwise be provided in writing by DIGITAL.
The material in this document is for information purposes only and is
subject to change without notice. DIGITAL assumes no responsibility
for the use or reliability of software and equipment which is not
supplied by it.
DIGITAL assumes no responsibility for any errors
which may appear in this document.

contents
CHAPTER 1 SK FORTRAN
Introduction ................................ ,..................................... .
Character Set ............................................................... .
FOR TRAN Constants ................................................. .
Integer Constants .............................. ~ ................. ..
Real Constants ..................................................... .
Hollerith Constants ............................................... .
FORTRAN Variables ................................................... .
Integer Variables ................................................... .
Real Variables ....................................................... .
Scalar Variables ..................................................... .
Array Variables ..................................................... .
Subscripting ............................................................ .
Expressions ................................................................... .

1-1
1-2
1-2
1-2
1-3
1-3
1-3
1-4
1-4
1-4
1-5
1-5
1-6

FORTRAN Statements ..................................................... .
Line Continuation Designator ....................................... .
Comments ..................................................................... .

1-8
1-8

Arithmetic Statements ....................................................... .

1-10

Input/ Output Statements ................................................... .
Data Transmission Statements ....................................... .
READ Statement ....... ,................................................. .
WRITE Statement ........ ~ .............................................. .
. D es1gna
.
t'ions ............................................ .
D ev1ce
FORMAT Statement····························:·························
Numeric Fields ..................................................... .
Numeric Input Conversion ................................... .
Alphanumeric Fields ............................................. .
Hollerith Conversion ............................................. .

1-10

1-9

1-11
1-13
1-14
1-14
1-15
1-16
1-17
1-18

1-20

Blank or Skip Fields ............................................
Mixed Fields ...............................,...........................
Repetition Fields .. .. .. ..... ... ... .. ..... .. ... ... .. .. .. .. .. .. ... ...
Repetition of Groups .. ..... .... .. ... .. ....... .... .. .... .. .... ...
Multiple Record Formats .. .. ... .... ...... ..... ... .... ... .. ....

1-21
1-21
1-21
1-22
1-22

Control Statements ............................................................

1-23
1-23
1-23
1-24
1..24
1-24
1-26
1-26
1-26
1-27
1-27

GO TO Statement .. .. .................. .. ......... .. ....... ........... .... .
Unconditional GO TO ..........................................
Computed GO TO ............................................... ~..
IF Statement .. .... ...... .. ............ .. .. ... ... ..... ... . ... ........... .......
DO Statement ............................ .
CONTINUE Statement..................................................
PAUSE, STOP and END Statements .......................... ~.
PAUSE Statement..................................................
STOP Statement ....................................................
END Statement ................ ".....................................
1

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

Specification Statements ............ :.... . .. . .. ... ... . . .. . . ... .. . . ... ... .. ..

COMMON Statement .. ........ .... .. ... ... .... .... .... ... .... .... .... ...
DIMENSION Statement ......... ... .. ............ ....... .... .... .. ... ..
EQUIV ALENCE Statement ... ... .... ... .... ... .... ....... .... ..... ..
Subprogram Statements . .. .. .. .. .. .. .. .... .. .. .. .. .. .. ... .. .. ... .. .. .. .. .. .

Function Subprograms .... ... .. ... ..... ...... .... ...... .. ......... ..... .
Subroutine Subprograms ...................................... :.. .... ...
CALL Statement........................................................
RETURN Statement ..................................................
Function Calls ................................................................
Library Subprograms .... ..... .. .. ..... .... ..... .. ..... .... .... .... ... ...
Floating-Point Arithmetic ..............................................

1-27
1-28
1-28
1-29
1-29
1-30
1-31
1-33
1-34
1-34
1-34
1-36

The IOPEN Subroutine ................................................
The OOPEN Subroutine .. .. .. .. ............. ... ... ... .... .. .... .. .... ..
The OCLOSE Subroutine .. .. ..... .. .. ... ... ... .............. ........
The CHAIN Subroutine .. ... ..... ... .. ... .... .. ........ .. .... ... ... ....
The EXIT Subroutine .... .. .. ... ..... .. .. .. .... .. .... .. .... .. .. .. .... ..

1-37
1-37
1-38
1-38
1-39
1-39

DECtape·I/0 Routines......................................................
OS/8 FORTRAN Library Subroutines..............................

1-39
1-42

Device Independent 1/0 and Chaining..............................

Mixing SABR and FORTRAN Statements........................

1-44

Size of a FORTRAN Program .. .. ... .. ... ... .. .. .. .. .. ... ... . .. .. .. ....

1-45

Operating Instructions .. ...... ... ..... .. ... .... ... ... ... .. .. ... ... ... .. .......
Loading and Operating the Compiler .. ... .. .. .. .. .. .. . .. .. .. .. ..
8K FORTRAN Errors ..................................................

1-46
1-46
1-47

Compiler Error Messages .. .. ... ... .. .. .. .. ... .. .. ... ... .. .. .

1-48

OS/8 FORTRAN Library Error Messages............
Loading the SABR Assembler .. ..... .. .... ... .. .. .. ... .... .. .... .....
Operating the SABR Assembler ....................................
Method 1 ................................................................
Method 2 ....... .........................................................
Method 3 .................................................................
The Linking Loader ......................................................
Loading the Linking Loader .. .. .. .. .... .. ... .... .. . .. .. .. .. ..
Loading Relocatable Loader .. .. .. .. .. .. ... .. .. .. . .. .. .. ... .
Executing the FORTRAN Program .. .. ..... .. .. ... ... . .. .. .. ....

1-50
1-52
1-52
1-53
1-54
1-55
1-55
1-5 6
1-5 6
1-57

D~monstration Program

....................................................

1-58

.Statement and Format Specifications .. ... .. .. .. .. .. .. ..... .. .. .. .. .. ..

1-62

Storage Allocation .. ...... ...... ......... ........ .... ..... .... ... ............ ...
Representation of Constants and Variables ....................
Integers ...... .... ........................ ... .. .. .... ........ .. .... .... ..
Real Numbers ........................................................
Storage of Arrays ... ... .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ... .. ... ... . .. ... .. .. .
Representation of N-Dimensional Arrays .. .... .. .. .. .. .... ..
Common Storage Allocation .. .. .. .. .. .. .. .. .. .. ... .. .. .. .. ... .. .. .. ..

1-65
1-65
1-65
1-66
1-67
1-68
1-69

Implementation Notes ....................... :................................
Implied DO Loops ... .. .. .. .. .. .. .... ... .. .. .. .... ... .. .. .. .. .. ..... .... ..
FORMAT Handling ..... .............. ....... .. .... .. .. ... ... .. .... ... ...
Special I/0 Devices........................................................

1-70
1-70
1-71
1-73

CHAPTER 2

SABR ASSEMBLER

The Character Set ........................................................
Alphabetic ... ... .. ........ ... .......... ... .. .... .. ........... ...... ....
Numeric .... ... ... ...... .................... .... ... ............. ..... ....
Special Characters .. ....... ........... .... .. .. ...... ... ..... .....
Vl

2-2
2-2
2-2
2-2

Statements ..... . ...... .. .. .. ... ..... ....... . ... .. ... .... .. ... ... .. . .. .. ..... ..
Labels ....................................................................
Operators . ... .. .... ... .. ... . ..... .. . ... ... .. .. ... .. ... .. .... ... ..... ...
Operands ................................... ~............................
Comments ..............................................................
Incrementing Operands ... . .... .. . .. . .. .. .. . .... ... .. ... . .. . .. .. .. .. .
Pseudo-Operators . .. ... ..... ..... .. . ... ... .. ..... ... ... ... . ... ... ... ...
Assembly Control ........................................... ;.. . ...
Symbol Definition ........................................ ·..........
Data Generating . .. . ..... . .... .. ... ... ..... ... ... ... ... .. . ... .... . ..
Subroutines ... .... ..... . ... ..... ..... .. ..... . .... .... ... .. ... .... ... .... . ..
CALL and ARG . ... ... ..... .. . .. .... ...... .. ... ... .... ... .. ..... ...
ENTRY and RETRN ...........................................
Example ............................... ;.. .... .... ... ... .. .... .. ..... . ..
Passing Subroutine Arguments ..... ."................ ~.............
DUMMY

2-3
2-4
2-4
2-5
2-8
2-9
2-10
2-11
2-15
2-17
2-19
2-21
2-22
2-23
2-24

······························································

2-24

SABR Operating Characteristics ... .. .. .. . .. ... . .. . ... .. ... ...
Page-by-Page Assembly ................. ;.. ... .. .... . .. .. .... ..
Multiple Word Instructions .............. ................. ...
Run-Time Linkage Routines .. .. . ...... .. .. .... .. .... ..... ..
Skip Instructions .. .. .. ... .. .. .... . .. . .. .. .. .. .. ... .. .. ... ...........
Program Addresses .. ... .. ... .. . ... .. .. . ... ... .. ... .. .. .. .. . .. .. . ..
The Symbol Table ................................................

2-28
2-28
2-30
2-30
2-33
2-34
2-34

The Subprogram Library ...........................................
Input/Output ........................................................
Floating-Point Arithmetic ......................................
Integer Arithmetic ..................................................
Subscripting .. .... .... .... .. .... .. .. ... ..... .. .... ... ... ... ..... .... ..
Functions ...... .. . ... .. .. ... ... . .. ... .. . . .. .. .. .. .. .... .... .. .. . ..... ..
Utility Routines ......................................................
DECtape I/0 Routines ........................................
The Binary Output Tape ..........................................
Loader Relocation Codes ......................................
Sample Assembly Listings ............................. ~..........
SABR Programming Notes ......................................
Optimizing SABR Code .......................................

2-35
2-36
2-37
2-39
2-39
2-40
2-41
2-43
2-45
2-45
2-49
2-53
2-53

Vll

Calling the OS/8 USR and Device Handlers ........
Loading and Operating SABR ..................................
Assembly Procedure .. .. .. .. .... .. ... .. .. .... .. ...... .. ... .. .. .. ..
Procedure for use as FORTRAN Pass 2 ..............
The Linking Loader .... .... ........ ............ .... .......... ... ...
Operation ....................................... :......................
Linkage Routine Locations .. .. .. .. ...... .. .. ...... .. .. .. .. ..
Switch Register Options ... .. .. ... .. .... .. ..... .. ... .. .. ... ... .. .
Loading the Linking Loader .. .. .. ... ... .. .. ... .... ... ... .. .
Loading Relocatable Programs ..... ..... ........ ..... .....
Error Messages ........................................................
SABR ....................................................................
Linking Loader .... .... .. .... ... .. .. ... .. ... .... .. .. .... .. .. ... ....
Library Programs ..................................................
.Demonstration Program Using Library Routines ....

2-56
2-56
2-57
2-58
2-58
2-59
2-60
2-60
2-62
2-62
2-64
2...64
2-65
2-67
2-68

Appendix A

A-1

Appendix B

B-1

Appendix C

C-1

VIU

chapter1
s1< r:ortran
INTRODUCTION
This chapter presents a version of FOR TRAN II specifically designed for the PDP-8/I, ~8/L, -8, and -8/E computers, with at
least 8K words of core memory, a Teletype; and a high-speed reader
and punch. Although the information contained in this chapter
deals particularly with the 8K FORTRAN available under the OS/8
Operating System, it is applicable as well to 8K paper tape FORTRAN. In cases where there are inconsistencies between the two,
they are clearly noted.
"8K FORTRAN" is used interchangeably to designate both the
8K FORTRAN -language and the translator, or compiler. The
language enables the programmer to express his problem using
English words and mathematical statements similar to the language
of mathematics and yet acceptable to the computer. The FORTRAN source program may be initially prepared off-line or by
using the appropriate Editor program. The compiler translates the
programmer's source program into symbolic language (SABR).
The symbolic version of the program is then assembled into relocatable binary code, which is the language of the computer.
The 8K paper tape FORTRAN system c'onsists of a one-pass
FORTRAN compiler, the SABR Assembler, the Linking Loader,
and a library ef---'Subprograms. Methods of loading and operating
8K paper tape FORTRAN are discussed toward the end of this
chapter.
OS/8 SK FORTRAN is an expanded version of 8K paper
tape FORTRAN which is designed to run under the OS/8 Operat-ing System. It includes features not found in the paper tape version
such as Hollerith constants, implied DO loops,) chaining, mixing of
SABR and FORTRAN statements, and device independent 1/0.
It is called from the OS/8 Keyboard· Monitor. Complete operating
instructions for the OS/8 FORTRAN system are found in the
OS/8 chapter of Introduction to Programming.
1-1

It is assumed that the reader is familiar with the basic concepts
of FORTRAN programming. Several excellent elementary texts
are available (such as FORTRAN Programming by Frederic
Stuart, published by John Wiley and Sons, New York, 1969, and
A Guide to FORTRAN Programming by Daniel D. McCracken,
published by John Wiley and Sons, New York) if review is needed.

Character Set
The following characters are used in the FOR TRAN language. 1
1. The alphabetic characters, A through Z.
2. The numeric characters, 0 through 9.
3. The special characters::.?

t
"

(
)

$
%
&

#
?

[
]

""'

<
>

(space)

FORTRAN Constants
Constants are self-defining numeric values appearing in source
sta.tements and are of three types: integer, real, and Hollerith.~
INTEGER CONST ANTS
An integer (fixed point) constant is represented by a digit string
of from one to four decimal digits, written with an optional sign,
1 Appendix B lists the octal and decimal representations of the FORTRAN
character set.
2 Of these, the characters" ! ,_$ % & # : ? < > j [] ""' ~may only appear
inside FORMAT statements or Hollerith constants.

Hollerith constants are available only in OS/8 FORTRAN.

1-2

and without a decimal point. An integer constant must fall within
the range -2047 to +2047. For example:
47
+4 7

( + sign is optional)

-2
0434
0

(leading zeros are ignored)
(zero)

REAL CONST ANTS
A real constant is represented by a digit string, an explicit
decimal point, an optional sign, and possibly an integer exponent to denote a power of ten (7.2 x 1Q:1 is written 7.2E+03).
A real constant may consist of any number of digits but only the
leftmost eight, digits appear in the compiled program. Real constants must fall within the range of ± 1. 7x10: 18 • (8K paper tape
FORTRAN allows a range of .14x io-:: 8 to 1.7xl0:18 for real constants.) For example: c
+4.50
4.50
-23.09
-3.0E14

( + is optional)

(same as -3.0 x 1014)

HOLLERITH CONSTANTS
A Hollerith constant is a string of up to 6 characters (including
blanks) enclosed in single quotes. A Hollerith constant is treated
like a real constant, except that it cannot be used in arithmetic
expressions other than for simple equivalence (A==B). Any character except the quote character itself can be used in a Hollerith
constant. For example:
I

,VJ 0 VJ I

'A+~3=C'

} r.1 I

FORTRAN Variables
A variable is a named quantity whose value may change during
execution of a program. Variables are specified by name and type.
The name of a variable consists of one or more alphanumeric
characters the first of which must be alphabetic. Although any
number of characters may be used to make up the variable name,
only the first five characters are interpreted as defining the name;
1-3

the rest are ignored. For example. DELTAX. DELTA Y, and
DELTA all represent the same variable name.
The type of variable (integer or real) is determined by the
first letter of the variable name. A first letter of I. J. K, L, M. or
N indicates an integer variable. and any other first letter indicates
a real variable. Variables of either type may be either scalar· or
array variables. A variable is an array variable if it first appears in
a DIMENSION statement.
INTEGER VARIABLES
The name of an integer variable must begin with an I, J, K.
L, M. 9r. N. An integer variable undergoes arithmetic calculations with automatic truncation of any fractional part. For example,
if the current value of K is 5 and the current value of J is 9. J /K
would yield 1 as a result.
Integer variables may be conyerted to real variables by the
function FLOAT (see Function Calls) or by an arithmetic statement (see Arithmetic Statements). Integer variables must fall within
the range -2047 to +2047.
Integer arithmetic operations do not check for overflow. For
example. the sum 204 7 + 204 7 will yield a result of -2. For more
information refer to C_hapter 1 of Introduction to Programming or
any text on binary arithmetic.
REAL VARIABLES
A real variable name begins with any alphabetic character other
than I, J, K, L. M. or N. Real variables may be converted to integer
variables by the function IFIX (see Function Calls) or by an
arithmetic statement. Real variables undergo no truncation m
arithmetic calculations.

7
(

SCALAR VARIABLES
A scalar variable may be either integer or real and represents a
single quantity. For example:
L vJ
A

G2
TOTAL
.J

1-4

ARRAY VARIABLES
An array (subscripted) variable represe.nts a single element of a
one- or two-dimensional array of quantities. The array element is
denoted by the array name followed by a subscript list enclosed in
parentheses. The subscript list may be any integer expression or
two integer expressions separated by a comma. The expressions
may be arithmetic combinations of integer variables and integer
constants. Each expression represents a subscript, and the values
of the expressions determine the referenced array element. For
example, the row vector Ai would be represented by the subscripted
variable A (I), and the element in the second column of the first row
of the matrix A, would be represented by A (1, 2).
Examples of one-dimensional arrays are:
y ( 1)
PtJRTC~>

while a two-dimensional array appears as follows:

Any array must appear in a DIMENSION statement prior to its
first appearance in an executable statement. The DIMENSION
statement specifies the number of elements in the array.
Arrays are stored in increasing storage locations with the first
subscript varying most rapidly (see Storage Allocation). The twodimensional array B (J, K) is stored in the following order:
B(l, 1), B(2, 1), . . . , B(J, 1), B(l, 2), B(2, 2), ... , B(J, 2),
..• , B(J, K)
For representation of arrays of more than two dimensions, refer
to the section entitled Representation of N-Dimensional Arrays
toward the end of this chapter.
SUBSCRIPTING
Since excessive subscripting tends to use core memory inefficiently, it is suggested that subscripted variables be used judiciously. For example. the statement:

1-5

A=<<B<I>+C2>*B<I>+Cl>*B<I>

could be rewritten with a considerable saving of core memory as
follows:
T=B <I )
A=<<T+C2>*T+Cl>*T

Expressions
An expression is a sequence of constants, variables, and function
references separated by arithmetic operators and parentheses in
·accordance with mathematical convention and the rules given
below.
Without parentheses, algebraic operations are performed in the
following descending order:

**
* an·d I
+and-

exponentiation
unary negation
multiplication and division
addition and subtraction
equals or replacement sign

Parentheses are used to change the order of precedence. An
operation enclosed in parentheses is performed before its result is
used in other operations. In the case of operations of equal priority, the calculations are performed from left to right.
Integers and real numbers may be raised to either integer or real
powers. An expression of the form:
A**B
means An and is real unless both A and B are integers. Exponential
(ex) and natural logarithmic (log.. (x)) functions are supplied as
subprograms and are explained later.
Excluding ** (exponentiation), no two arithmetic operators may
appear in sequence unless the second is a unary plus or minus.
The mode (or type) of an expressJon may be either integer or
real and is determined by its constituents. Variable modes may not
be mixed in an expression with the following exceptions:
1. A real variable may be raised to an integer power:

1-6

2. Mode may be altered by using the functions IFIX and
FLOAT (see Function Calls):
A*FLOAfCI)

The I in example 2 above, indicates an integer variable; it is
changed to real (in floating point format) by the FLOAT function.
Zero raised to a power of zero yields a result of 1. Zero raised
to any other power yields a zero result. Numbers are raised to
integer powers by repetitive multiplication. Numbers are raised to
floating point powers by calling the EXP and ALOG functions.
A negative number raised to a floating point power does not cause
an error message but uses the absolute value. Thus, the expression
(-3.0)**3.0 yields a result of +27.
Any arithmetic expression may be enclosed in parentheses and be
considered a basic element.
IFIX<X+Y)/2
<ZETA)
<COS<SIN<PI*EM)+X))

An arithmetic expression may consist of a single element (constant, variable, or function call). For example:

TAi\JC T'-1STA)

Compound arithmetic expressions may be formed using arithmetic operators to combine basic elements. For example:
;< + 3 •

TOTAL/A
TANCPIH>VJ)

Expressions preceded by a + or a - sign are also arithmetic expressions. For example:
+ ;<

-c ALPi-lA*BETA)
-SQRTC -GA,V1MA)

1-7

As an example of a typical arithmetic expression using arithmetic
operators and a function call, the expression for the largest root of
the general quadratic equation:
-b +

V b:! _.:. 4ac
2a

is coded as:

FORTRAN STATEMENTS
A FORTRAN source program consists of a series of statements,
each of which must start on a separate line. Any FORTRAN
statement may appear in the statement field (columns 7 through 72)
and may be preceded by a positive number, called a statement
number, of from 1 to 4 digits which serves as an address label and
is used when referencing the statement. When used, statement numbers are coded in columns 1 through 5 of the 72 column line. Statement numbers need not appear in sequential order, b.ut no two statements should have the same number. Statement numbers are limited
to a value of 2047 or less.
When using the Symbolic Editor to create the source program,
typing a CTRL/TAB (generated by holding down the CTRL key
and depressing TAB) causes a jump over the statement number
columns and into the statement field. Except for data within a
Hollerith field (see Input/Output Statements), spaces are ignored
by the compiler. The programmer may use spaces freely, however,
to make the program listing more readable and to organize data
into columns.
Line Continuation Designator
Statements too long for the statement field of a single Teletype
line may be continued on the next line. The continued portion must
not be given a line number, but must have an alphanumeric character other than 0 in column 6. If the Symbolic Editor is used, the programmer may type a CTRL/TAB followed by a digit from 1 to 9
before continuing the line. The,continuation character is not treated
as part of the statement.

1-8

For example, using spaces, a continued statement would look as
follows:
WR IT E C3, 30 )
30

FORMAT
1 PARTS

FOLLC~ING DATA IS GROUPED INTO THREE
THE HEADINGS X, y, AND Z·')

c1x~'THE
U~DFR

Using tabs, the same ~tatement would be typed:
WR I TE C3, 30 )
30

FOR~AT

ClX,'THE FOLLO~ING DATA IS GROUPED INTO THREE
1 PARTS UNDER THE HEADINGS X, y, AND z.•)

There is no limit to the number of continuation lines which may
appear. However, one restriction is that an implied DO loop must
not be broken, but must be on one line. For ease in program correction, it is recommended that continuation lines be minimized.
Comments

The letter C in column 1 of a line designates that line as a comment line. A comment appears in a program listing but has no
effect on program compilation. Any number of comment lines may
appear in a given program, and comments that are too long for
one line may be continued by placing a C in the first column of the
next line. A comment line may not appear between another line
and its continuation.
FORTRAN statements are of five types:

J2_a_~J'\.,Q_

S..A.~

1. Arithmetic, defining calculations to be performed;
2. Input/Output, _directing communication between the program and input/ output devices;
3. Control, governing the sequence of execution of statements
within a program;
4. Specification, describing the form and content of data within
the program;
5. Subprogram, defining the form and occurrence of subprograms and subroutines.
Each of these five types is explained in the following paragraphs.
1-9

ARITHMETIC STATEMENTS
Constants and variables, identified as to type and connected by
logical and arithmetic operators form expressions: one or more
expressions form an arithmetic statement. Arithmetic statements
are of the general form:

V=E
where V is a variable name (subscripted or nonsubscripted), E is
an expression, and = is a replacement operator. The arithmetic
statement causes the FORTRAN object program to evaluate the
expression E and assign the resultant value to the variable V. Note
that
signifies replacement, not equality. Thus, expressions of th.e
form:

are quite meaningful and indicate that the value of the variable A
is to be changed.
For example:
Y=l·l*Y
P=X**2+3.*X+2.0
XCN)=EN*ZETA*CALPHA+EM/Pl)

The expression value is made to agree in type with the variable
before replacement occurs. In the statement:
META=W* CABETA+E)

since MET A is an integer and the expression is real, the expression
value is truncated to an integer before assignment to MET A.
I

INPUT/OUTPUT STATEMENTS
Input/Output (1/0) statements are used to control the transfer
of data beween computer memory and peripheral devices and to
specify the format of the output data. 1/0 statements may be divided into two categories:
1-10

1. Data transmission statements, READ and WRITE, specify
transmission of data between computer memory and 1/0
devices.
2. Nonexecutable FORMAT statements enable conversion between internal data (within core memory) and external data.
Data Transmission Statements
The two data transmission statements, READ and WRITE, accomplish input/output transfer of data listed in a FORMAT statement. The two statements are of the form:

READ (unit, format) 1/0 list
WRITE (unit, format) 1/0 list
where unit is a device designation which can be an integer constant
or an integer variable, format is a FORMAT statement line number, and the I I 0 list is a list specifying the order of transmission of
the variable values. During input, the new values of listed variables
may be used in subscript or control expressions for variables appearing later in the list.
For example:

reads a new value of L and uses this value in the subscripts of A
and B; where 2 is the device designation code, and t,000 is> a
FORMAT statement number.
An element in an I/0 list can take one of the following forms:
1. Arithmetic expression: expressions more complicated than a
single variable (which can be subscripted) are meaningless
in an input operation.
2. The name of an array (1 or 2 dimensional) 4 : this indicates
that every element of the array is to be transmitted. Elements
are transmitted in the order in which they are stored in core.
For example:
DIMENSION AC2,2)
READ

Cl,100)

Arrays in l/O lists are allowed only in OS/8 FORTRAN.

1-11

reads:

3. Implied DO Loops 5 of the form:

repeat the list elements ( s11 ) with the value of i being equal
to m 1 through m:! having an optional step value of m:~. The
m's are integer constants or variables, i is an integer variable,
and s1-s11 are the I/0 list elements (possibly including an implied DO loop). For example:
DIM Er\ S ION AC 3, 6 )
WR±TE Cl,100) I,CACJ,I)J=l,3)

will outp_ut the values:

It is important to remember that when using implied DO
loops, the entire implied DO loop must be on the same input
line or card. An impli~d DO loop cannot be continued onto
the next line with a continuation character.
If no I/O list is specified for a WRITE statement, then information is read directly from the specified FORMAT statement
and written on the device designated.

Data appears on the external device in the form of records. 6 All
information appearing on input is grouped into records. On output
to the printer a record is one line. The amount of information contained in each ASCII record is specified by the FORMAT statement and the I/ 0 list.
Implied DO loops are not allowed in 8K paper tape FORTRAN. Refer
to Implementation Notes at the end of this chapter for a way of circumventing this restriction.
5

6 This should not_be confused with the OS/8 record, which is equal to 25610
words (2 DECtape blocks with the 129th word of each block ignored.)

1-12

Each execution of an 1/0 statement initiates the transmission of
a new data record. Thus, the statement:
READC1,100)FIRST,SECO~D,THIRD

is not necessarily equivalent to the statements below where 100 is
the FORMAT statement referenced:

!
/

READC1,100)FIRST
READC1,100)SECOND
READC1,100)THIRD

/
i

)

In the second case, at least three separate records are required~
whereas, the single statement
READ (d, f) FIRST, SECOND, THIRD
may require one, two, three, or more records depending upon
FORMAT statement f.

If an I/0 statement requests less than a full record of information, the unrequested part of the record is lost and cannot be recovered by another 1/0 statement without repositioning the record.
If an I/O list requires more than one ASCII record of information, successive records are read.
READ Statement
The READ statement specifies transfer of information from a
selected input device to internal memory, corresponding to a list
of named variables, arrays or array elements .. The READ statement
assumes the following form:
READ ( d, f) list
where d is a device designation which may be an integer constant
or an integer yariable, f is a FORMAT statement line number, and
list is a list of variables whose values are to be input.
The READ statement causes ASCII information to be read from
the device designated and stored in memory as values of the
variables in the list. The data is converted to internal form as
specified by the referenced FORMAT statement.

1-13

I
I

\. ..

For example:
READC1,15)ETA,PI

WRITE Statement
The WRITE statement specifies transfer of information from
the computer to a specified output. device. The WRITE statement
assumes one of the following forms:

WRITE ( d, f) list
WRITE (d, f)
where d is a device designation (integer constant or integer variable), f is a FORMAT statement line number, and list is a list of
variables to be output.
The WRITE statement followed by a list causes the values of the
variables in the list to be read from memory and written on
the designated device in ASCII form. The data is converted to external form as specified by the designated FORMAT statement.
The WRITE statement without a list causes information (generally Hollerith type) to be read directly from the specified format
and written on the designated device in ASCII form.
DEVICE DESIGNATIONS
The 1/0 device designations used in the READ and WRITE
statements are described in Table 1-1.
Table 1-1

Device Code
1
2
37
47

Device ·Designations

Input Designation

Output Designation

Teletype keyboard or
Teleprinter
low-spce~ reader
High-speed reader
High-speed punch
Card reader (CR8/I) Line printer (LP08)
Assignable device
Assignable device
(see Device Independent 1/0 and Chaining)

Devic~

code 3 is assigned to the card reader (for all READ
statements), and the line printer (for all WRITE statements). The
card reader uses a two-page device handler, which is too large to
7

Device designations 3 and 4 are available only in OS/8 FORTRAN.

1-14

be used wit·h the device independent I/O feature (device code 4).
Therefore, the card reader has·its own device code.
The line printer is a separate output device because it can require
special formatting, such as inserting a Form Feed to skip to the
top of a page. The contents of the first column of any line is a control character. These control characters are never printed. They
are as follows:
Character in Column 1

Resulting Spacing
single space
double space
skip to top of
next page (Form
Feed)
single space

space
0
1

all others

FORMAT Statement
The nonexecutable FORMAT statement specifies the form and
arrangement of data on the selected external device. FORMAT
statements are of the form:

where m is a statement number and each S is a data field specification. Both numeric and alphanumeric field specifications may appear in a FORMAT statement. The FORMAT statemenr also
provides for handling multiple record formats, skipping characters,
space insertion, and repetition.
FORMAT statements may be placed anywhere in the source
program. Unless the FORMAT statement contains only alphanumeric data for direct 1/0 transmission, it will be used in conjunction with the list of a data transmission statement.
During transmission of data, the object program scans the designated FORMAT statement; if a specification for a numeric field
is present, and the data transmission statement contains items remaining to be transmitted, transmission takes place according to the
specification. This process ceases and execution of the data transmission statement is terminated as soon as all specified items have
been transmitted. The FORMAT statement may contain specifications for more items than are indicated by the data transmission
1-15

statement. The FORMAT statement may also contain specifications for fewer items than are indicated by the data transmission
statement, in which case, format control reverts to the rightmost
left parenthesis in the FORMAT statement. If an input list requires more characters than the input device supplies for a given
record, blanks are inserted.
1/0 information which is relevant to the 8K paper tap~ FORTRAN is contained in Implementation Notes at the end of this
chapter.
NUMERIC FIELDS
Numeric field specification codes and the corresponding internal and external forms of the numbers are listed in Table 1-2.
Table 1-2

Conversion
Code
E

Numeric Field Codes

Internal Form

External Form

Binary floating point Decimal floating points
with E exponents:

0.324E+10
F
I

Binary floating point Decimal floating point
with no exponent: 283.75
Binary integer
Decimal integer: 79

Conversions are specified by the form:
rEw.d
rFw.d
rlw
where r is a repetition count, E, F, and I designate the conversion
code, w is an integer specifying the field width, and d is an integer
specifying the number of decimal places to the right of the decimal
point. For E and F input, the position of the decimal point in the
ex tern al field takes precedence over the val uc of d. For example:

When using E format, or with numbers less than 1.0 when usin~ F format
in a WRITE statement. a zero will be typed to the left of the decimal point.
This is not true in 8K paper tape FORTRAN. in which case the example
given would by output as: .324E+ JO
k

1-16

could. be used to output the line

-lr.60

0.59624575E+03

oh the output listing.
The field width should always be large enough to include the
decimal point, sign, and exponent (plus a leading zero in OS/8
FORTRAN). In all numeric field conversions, if the field width
is not large enough to accommodate the converted number, asterisks will be printed; the number is always right-justified in the field.
NUMERIC. INPUT CONVERSION
In general, numeric input conversion is compatible with most
other FORTRAN processors. A few exceptions are listed below:
1. Blanks are ignored except to determine in which field digits
fall. Thus, numbers are treated· as if they are right-justified
within a field. In an F5.2 format, the following:
bbb12
12bbb
00012
are read as the number 0.12 (where 'b' represents a blank
space).
2. A null line delimited by two carriage return/line feed
( CR/LF) combinations is treated as a line of blanks, and
blanks are appended to the right of a line (if necessary) to
fill out a FORMAT statement. Thus:
12 (CR/LF)
12bbb
bbbl2
are identical under an F5 .2 format. If an entire line is blank,
numeric data from that line is read as zeros.
1-17

3. No distinction is made between E and F format on input.
Thus:
100.
100E2
1.E2
10000
are all read identically under either an F5.2 or E5.2 format.
ALPHANUMERIC FIELDS
Alphanumeric data can be transmitted in a manner similar to
numeric data ~y use of the form

rAw
where r is a repetition count, A is the control character, and w is
the number of characters in the field. Alphanumeric characters are
transmitted as the value of a variable in an 1/0 list; the variable
may be either integer or real.
Although w may have any value, the number of characters transmitted is limited by the maximum number of characters which can
be stored in the space allotted for the variable. This maximum
depends upon the variable type; for a real variable the maximum
is six characters, for an integer variable the maximum is two.
characters. The characters are stored in stripped ASCII format. If
not enough data is supplied as input to the variables, the data is
padded with blanks on the right. For example:

READ c 1 , 20) 1¥11 , 1¥12, 1¥13, 1¥14, 1¥15, WS, ·"'11, ,.....,g
FORMAT C8Al)

if the user types at this point:
123ABC

followed by a carriage return, the following are the values of the
variables:

1-18

Variable

Decimal

Octal

ASCII

Ml
M2·
M3
M4

~928

6140
6240
6340
0140
0240
0340
4040
4040

1
2

M6
M7

-864
-800
96
160
224
-2016
-2016

A
B

blank
blank

If the above had been read rn4A2)ormat, the values would be as
follows:
'-,,. · _,,.,
Octal

Decimal

Variable

ASCII

Ml
·M2
M3
M4

6162
-910
6301
-831
0203
131
4040
-2016
................. ..
4040
-2016

1 2
3 A
BC
blanks

As a second example:
20

READ CJ,20>
FORMAT CA6>

ALP~A

the user types:
123AB

and a carriage return, and the octal value of ALPHA is:
6162

6301

0240

NQTE
The numeric value of alphanumeric
characters stored in floating point
variables is generally not meaningful.

1-19

blanks

Appendix B lists the octal and decimal (in Al format) representations o~.FORTRAN character set.. The decimal representation applies~~to 8K paper tape~S/8 FORTRAN.
HOLLERITH CONVERSION
Alphanumeric data may be transmitted directly from the FORMAT statement by using Hollerith (H) conversion. H-conversion
format is normally referenced by WRITE statements only.
In H-conversion, the alphanumeric stringjs specified by the form

where H is the control character and n is the number of characters
in the string, including blanks. For example, the statement below
· can be used to print PROGRAM COMPLETE on the output listing.
FORrY:AT C1 7H PRO GRAM CO.MPLETE)

A Hollerith string may consist of any characters capable of
representation in the processor. The space character is a valid and
significant character in a Hollerith string.
An attempt to use H format specifications with a READ statement will cause characters from the format field to be either printed
or punched. This can be a useful feature since it provides a simple
way of identifying data that is to be read from the Teletype keyboard. For example, the following instructions:
30

READ Cl,30)A,B
FORMAT C4HA = ,F7.2/4HB

= ,F7.2)

cause A
and B
to be printed out before the data is read.
By merely enclosing the alphanumeric data in single quotes, the
same result is achieved as in H-conversion; on input, the characters
between the single quotes are typed as output characters, and on
output, the characters between the single quotes (including blanks)
are written as part of the output data. For example, when referred
to from a WRITE statement:
50

FORMAT C' PROGRAM COMPLETE')

1-20

causes PROGRAM COMPLETE to be printed. This method
eliminates the need to count characters.
BLANK OR SKIP FIELDS
Blanks can be introduced into an output record or characters
skipped on an input record by use of the nX specification. The
number n indicates the number of blanks or characters skipped and
must be greater than zero. For example:
FORMATCSH STEPI5,10X2HY=F7·3)

can be used to output the line:
STEP

3·872

MIXED FIELDS
A Hollerith format field may be placed among other fields of
the format. The statement:
FORMATCI5,7H FORCE=F10.5)

can be used to output the line:
22 FORCE=

17·68901

The separating comma may be omitted after a Hollerith format
field, as shown above.
REPETITION OF FIELDS
Repetition of a field specification may be specified by preceding
the control character E, F, or I by an unsigned integer giving the
number of repetitions desired.

is equivalent to:

1-21

REPETITION OF GROUPS
A group of field specifications may be repeated by enclosing the
group in parentheses and preceding the whole with the repetition
number.
For example:

is equivalent to:

MULTIPLE RECORD FORMATS
To handle a group of output records where different records
have different field specifications, a slash is used to indicate a new
record. For example, the statement:
FORMAT<3I8/!5,2F8·4)

is equivalent to:
FORMAT< 318)

for the first record and
FORMAT< !5,2F8.4)

for the second record.
The separating comma may be omitted when a slash is used.
When n slashes appear at the end or beginning of a format, n blank
records may be written on output (producing" a CR/LF for each
record) or ignored on input. When n slashes appear in the middle
of a format, n-1 blank records are written or n-1 records skipped.
Both the slash and the closing parenthesis at the end of the format
indicate the termination of a record. If the list of an I/0 statement dictates that transmission of data is to continue after the
closing parenthesis of the format is reached, the format is repeated
1-22

from the last open parenthesis of level one or zero. Thus, the
statement:

causes the format:

to be used on the first record, and the format:

to be used on succeeding records.
As a further example, consider the statement:

The first record has the format:

~and successive records have the format:

CONTROL STATEMENTS
The control statements GO TO, IF, DO, PAUSE, STOP, and
END alter the sequence of statement execution, temporarily or
permanently halt program execution, and stop compilation.

GO TO Statement
The GO TO statement has two forms: unconditional and computed.
UNCONDITIONAL GO TO
Unconditional GO TO statements are of the form:
GO TO n
1-23

where n is the number of an executable statement. Control is transferred to the statement numbered n.
COMPUTED GO TO
Computed GO TO statements have the form:
GO TO (n1, n2, . . . , nk), J
where n 1 , n:!, . . . , nk are statement numbers and J is a nonsubscripted integer variable. This statement transfers control to the
statement numbered n 1 , n 2 ••• , nk if J has the value 1, 2, ... , k,
respectively. The index (J in the above example) of a computed
GO TO statement must never be zero or greater than the number
of statement numbers in the list (in the example above, not greater
thank). For example. in the statement:

the variable K acts as a switch, causing a transfer to statement 20
if K == 1, to statement 10 if K == 2, or to statement 5 if K = 3.
IF Statement
Numerical IF statements are of the form:

IF (expression) n 1, n 2 , n:l
where ni, n:!, n:{ are statement numbers. This statement transfers
control to the statement numbered n 1 , n:!, n:{ if the value of the
numeric expression is less than, equal to, or. greater than zero,
respectively. The expression may be a simple variable or any
arithmetic expression.
IF CETA)4,7,12
IFCKAPPA-LC10))20,14,14

DO Statement
The DO statement simplifies the coding of iterative procedures.
DO statements are of the form:

DO n i-'---- m1, m:!, m:i
where n is a statement number, i is a scalar integer variable, and
mi, m2, m:i are integer constants or nonsubscripted integer variables. If m:i is not specified, it is understoocl to be 1.

1-24

The DO statement causes the statements which follow, up to
and including the statement numbered n, to be executed repeatedly.
This group of statements is called the range of the DO statement.
In the example above, the integer variable i is called the index, the
values of m 1 , m:!, ma are, respectively, the initial, terminal, and increment values of the index.
For example:
DO 10 J= 1, N
DO 20 I=J,K,5
DO 30 L=I,J,K

The index is incremented and tested before the range of the DO is
executed. After the last execution of the range, control passes to.
the statement immediately following the terminal statement in wlfa~
is called a normal exit. An exit may also occur by a transfer out
of the range taking place before the loop has been -executed th~
total number of times specified in the DO statement.
/
DO loops may be nested, or contained within one another, provided the range of each contained loop is entirely within the range
of the containing DO statement. Nested DO loops may contain tlle
same terminal statement, however. A transfer into a DO loop from
outside the range is not allowed.
Within the range of a DO statement, the index is available for
use as an ordinary variable. After a transfer from within the range,
the index retains its current value and is available for use as a
variable.·n The values of the initial, terminal, and increment variables for the index and the index of the DO loop may not be
altered within the range of the DO statement.
After a normal exit from a DO loop, the index of the DO statement has
the value of the index the final time through the loop plus whatever increment was assigned. For example:
9

DO 10 I=l,S

after a normal exit the value of the index is 6. However, it is good programming practice to avoid using the index as a variable following a normal exit
until it has lJeenredefined, as according to ANSI FORTRAN Standards the
value is undefined.

1-25

The last statement of a DO loop must be executable, and must
not be an IF, GO TO or DO statement.
CONTINUE Statement
This is a dummy statement, used primarily as a target for transfers, particularly as the last statement in the range of a DO statement. For example, in the sequence:
DO 7 K=INIT,LIMIT

CONTINUE

a positive value of X(K) begins another execution of the range.
The CONTINUE provides a target address for the IF statement
and ends the range of the DO statement.
PAUSE, STOP and END Statements
The PAUSE and STOP statements affect FORTRAN object program operation; the END statement affects assembler operation
only.
PAUSE STATEMENT
The PAUSE statement enables the program to incorporate operator activity into the sequence of automatic events. The PAUSE
, statement assumes one of two forms:
or

PAUSE
PAUSE n

where n is an unsigned decimal number.
Execution of the PAUSE statement causes the octal equivalent
of the_ decimal number n to be displayed in the accumulator on the
user's console. Program execution may be resumed (at the next
executable statement) by depressing the CONTinue key on the
console.
In some cases the PAUSE statement may be used to give the
operator a chance to ,change data tapes or to remove a tape from
the punch. When this is done it is necessary to follow the PAUSE

1-26

statement with a call to the OPEN subroutine. This subroutine
initializes the 1/0 devices and sets hardware flags that may have
been cleared by pressing the tape feed button. For example:
PAUSE
CALL OPEN

NOTE
The CALL OPEN statement in OS/8 FORTRAN also resets all I/ 0 on unit 4, the assignable channel. Any further READs or
WRITEs on unit 4 without an intervening
IOPEN or OOPEN will print an error message and abort.
STOP STATEMENT
The STOP statement has the form:
STOP
It terminates program execution. STOP may occur several times
within a single program to indicate alternate points at which execution may cease. Program control is either directed to a STOP
statement or transferred around it.

END STATEMENTS
The END statement is of the form:
END
and signals the compiler to terminate compilation. The END statement must be the last statement of every program. (In OS/8
FORTRAN, the END statement generates a STOP statement as
well.)
SPECIFICATION STATEMENTS
Specification statements allocate storage and furnish information
about variables and constants to the compiler. The specification
statements are COMMON, DIMENSION, and EQUIVALENCE
and, when used, must appear in the program prior to any executable statement.
1-27

COMMON Statement
The COMMON statement causes specified variables or arrays to
be stored in an area available to other programs. By means of
COMMON statements, the data of a main program and/ or the
data of its subprograms may share a common storage area. Varibles in COMMON statements are assigned tQ locations in ascending order in field 1 beginning at location 200 storage allocation.
The COMMON statement has the· general form:
COMMON Vi, V;!, • . . , V

where v is a variable name. See the section entitled Common Storage Allocation for greater detail.
DIMENSION Statement
The DIMENSION statement is used to declare array identifiers
and to specify the number and bounds of the array subscripts. The
information supplied in a DIMENSION statement is required for
the allocation of memory for arrays. Any number of arrays may be
declared in a single DIMENSION statement, The DIMENSION
statement has the form:
DIMENSION s1 , s:!, ... , Su
wheres is an array specification. For example:.
DI MENS ION A C10 0 )
DIMENSION YC10),P0RTC25),8(10,10),JC32)

Dimension statements are used for the purpose of reserving
sufficient storage space for anticipated data; it is the user's responsibility to see that his subscripting does not conflict with the
DIMENSION statement" declarations. For example:
DIME~SIO~

I<l~>,JC10>,KC10>

1(2,4>=2
J(l2l=3

The above statements would assemble without error; at run time
I( 8) would be set equal to 2 and K(2) would be set equal to 3.

N<J3:E
When variables in common storage are
dimensioned, the COMMON statement must
appear before the DIMEN:Sl~,p~~tatem.ent.
1-28

EQUIVALENCE Statement
The EQUIVALENCE statement causes more than one variable
within a given program to share the same storage location. This is
useful when the programmer desires to conserve storage space. The
form of the statement is:
EQUIVALENCE (vi, v:! ... ) , ...
where v represents a variable name. The inclusion of two or more
variables within the parenthetical list indicates that these variables
are to share the same memory location and thus have the same
value. For example:
EQUIVALENCE< RED, BLUE>

The variables RED and BLUE are now of equal value. The subscripts of array variables must be integer constants. For example:
EQUIVALENCECX,AC3),y(~,l)),(BETAC8,2),AL~HA)

Because of core memory restrictions within the compiler, variables cannot appear in EQUIVALENCE statements more than
once.
EQUIVALENCE<A,B,C>

is valid, but the statement:
EQUIVALENCECA,B>,CB,C>

would not compile correctly.
Variables may not appear in both EQUIVALENCE and COMMON statements.
SUBPROGRAM STATEMENTS
External subprograms are defined separately from the programs
that call them, and are complete programs which conform to all
the rules of FORTRAN programs. They are compiled as closed
subroutines; that is, they appear only once in core memory regardless of the number or times they are used. External subprograms
are defined by means of the statements FUNCTION and SUBROUTINE. Functions and subroutines must be compiled indepen...
dently of the main program and thenJoaded together with the main
program by the Linking Loader.
1-29

NOTE
Care should be exercised when naming a
subprogram or subroutine. It must not have
the same name as any of the FORTRAN
library functions or subroutines, or assembler
mnemonics or pseudo-ops, as errors are likely
to result. The Library Functions are listed in
this chapter, and the symbol table for the
, SABR Assembler is listed in Appendix C.
Subprogram definition statements may optionally contain dummy
arguments representing the arguments, of the subprogram. They
are used as ordinary identifiers within the subprogram and are
replaced by the actual arguments when the subprogram is executed.

Functi@n·,··Subprograms
A function subprogram is a subprogram which is ca~~l:e:d·c..from
an arithmefrc expression within the main program and' returns a
single numeric value. A function. subprogram begins with a FUN CTI ON statement and ends with an END statement. It returns control to the calfing program by means of one or more RETURN
statements. The FUNCTION statement has the form:
FUNCTION identifier ( a 1 , a:! ... , au)
where FUNCTION (or FUNC) declares that the program which
follows is a function subprogram, and identifier is the name of the
function being defined. The identifier must appear as a scalar variable and be assigned a value during execution of the subprogram.
This value is the function's value.
Arguments appearing in the list enclosed in parentheses are
dummy arguments representing the function arguments. A function
must have at least one dummy argument. The arguments must
agree in number, order and type with the actual arguments used in
the cailing program. Function subprograms may be cailed with expressions and array names as arguments. The corresponding dummy
arguments in the FUNCTION statement would then be scalar and
array identifiers, respectively. Those representing array names must
appear within the subprogram in a DIMENSION statement. Dimensions must be indicated as constants and should be smailer

1-30

than or equal to the dimensions of the corresponding arrays in the
calling program. Dummy arguments to FUNCTION cannot appear
in COMMON or EQUIVALENCE statements within the function subprogram.
A function should not modify any arguments which appear in
the FORTRAN arithmetic expression calling the function. The
only FORTRAN statements not allowed in a function subprogram
are SUBROUTINE and other FUNCTION statements.
The type of function is determined by the first letter of the identifier used to name the function, in the same way as variable names.
The following short example calculates the gross salary of an
individual on the basis of the number of hours he has worked
(TIME) and his hourly wage (RATE). The function calculates
time and a half for overtime beyond 40 hours. The function name
is SUM.

10
20

FUNCTION SUMCTIME,RATE)
IF (TIME-40.l 10,10,20
SUM ; TIME * RATE
RETURN
SUM; <40·*RATE> + CTIME-40·>*1·5*RATE
RETURN
END

Depending upon which path the program takes, control will return to the main program at one of the two RETURN statements
with the answer. Assume that the main program is set up with a
statement to read the employee's weekly record fr9m a list of
information prepared on the high-speed reader:
READC2,5) NAME, NUM, NDEP, TIME, RATE

This statement reads the person's name, number, department number, time worked, and hourly wage. The main program then calculates his gross pay with a statement such as the following:
GROSS ;

SUMCTIME,RATE>

and goes on to calculate withholdings, etc.

Subroutine Subprograms
A subroutine subprogram is a subprogram which is called by
the main program via a CALL statement, and may return several

1-31

or no values. The subprogram begins with a SUBROUTINE statement and returns· control to the· calling program by means of one
or more RETURN s·tatements. The SUBROUTINE statement has
the form:
SUBROUTINE identifier (al, a:! ... an)
where SUBROUTINE declares the program which follows to be a
subroutine subprogram and the identifier is the subroutine name.
The arguments in the list enclosed in parentheses are dummy arguments representing the arguments of the subprogram. The dummy
arguments must agree in number, order, and type with the actual
arguments, if any, used by the calling program.
Subroutine subprograms may have expressions and. array names
as arguments. The dummy arguments may appear as scalar or array
identifiers. Dummy identifiers which represent array names must
be dimensioned within the subprogram by a DIMENSION statement. The dummy arguments must not appear in an EQUIVALENCE or COMMON statement in the subroutine subprogram.
A subroutine subprogram may use one or more of its dummy
identifiers to represent results. The subprogram name is not used
for the return of results. A subroutine subprogram need not have
any arguments, or may use the arguments to return numbers to the
calling program. Subroutines are generally used when the result of
a subprogram is not a single value.
Example SUBROUTINE statements are as follows:

S1JBROUTI NE FACTO
SUBROUTINE RESID
SUBROUTINE SERIE

c COEFF, N,KOOTS)
CNUM,N,OE~,~,RES>

The only FORTRAN statements not a"llowed in a subroutine subprogram are FUNCTION and other SUBROUTINE statements.
The following short subroutine takes two integer numbers from
the main program and exchanges their values. If this is to be done
at several points in the main program, it is a procedure best performed by a subroutine.
1-32

SUBROUTINE !CHGE CI,J>
ITEM= I
I=J
J=ITEM
RETURN
END

The calling statement for this subroutine might look as follows:
CALL ICHGF CM,N)

where the values for the variables M and N are to be exchanged.
CALL STATEMENT
The CALL statement assumes one of two forms:

CALL identifier
CALL identifier (a1, a:! ... , au)

The CALL statement is used to transfer control to a subroutine
subprogram. The identifier is the subroutine name.
The arguments (indicated by a 1 , through an) may be expressions or array identifiers. Arguments may be of any type, but must
agree in number, order, type, and array siz~ with the corresponding
arguments in the SUBROUTINE stat€_ment of the called subroutine. Unlike a function, a subroutine may produce more than one
value and cannot be referred to as a basic element in an expression.
A subroutine may use one or more of its arguments to return
results to the calling program. If no arguments at all are required,
the first form is used. For example:
CALL EXIT
CALL TEST CVALUE,123,275)

The identifier used to name the subroutine is not assigned ·a
type and has no relation to the types of the arguments. Arguments
which are constants or formed as expressions must not be modified'
by the subroutine.

1-33

RETURN STATEMENT
The RETURN statement has the form:
RETlJRN
This statement returns control from a subprogram to the calling
program. Each subprogram must contain at least one RETURN
statement. Normally, the last statement executed in a subprogram
is a RETURN statement; however, any number of RETURN statements may appear in a subprogram. The RETURN statement may
not be used in a main program.

Function Calls
Function calls are provided to facilitate the evaluation of functions such as sine, cosine, and square root. A function is a subprogram which acts upon one· or more quantities (arguments) to
produce a single quantity called the function value. A function call
may be used in place of a variable name in any arithmetic expression.
Function calls are denoted by the identifier which names the
function (i.e., SIN, COS, etc.) followed by an argument enclosed
in parentheses as shown below:
IDENT (ARG, ARG, ... , ARG)
where !DENT is the identifying function name and ARG is an
argument which may be any expression. A function call is evaluated before the expression in which it is contained.

Library Subprograms
The standard FORTRAN library contains built-in functions, including user-defined functions and subroutine subprograms.
Table 1-3 lists the built-in functions. These are open subroutines: they are incorporated into the compiled program each time
the source program names them.
Function and subroutine subprograms are closed routines; their
coding appears only once in the compiled program. These routines
are entered from various points in a program through jump-type
linkages.

l-34

NOTE
A FORTRAN compiler and its corresponding Library constitute an interlocking set of
programs. No user should attempt to compile
a program under OS/8 and load it with the
paper tape FORTRAN, or vice versa. Similarly, programs developed with the current
FORTRAN compiler should not be run under an old FORTRAN system.
Table 1-3

Function

Function Library

Definition

ABS(x)
IABS(x)
FLOAT(x)

the absolute value of x
the absolute value of x
convert x from integer to real format
IFIX(x)
convert x from real to integer format
IREM(O)
remainder of last integer divide is
feturnedlO
IREM(x/y) remainder of x/y is returned10
EXP(x)
exponential of x, eX
natural
logarithm of x, log('x
ALOG(x)
SIN(x)
sine of x, where x is given in
radians
COS(x)
cosine of x, where x is given Ill
radians
TAN(x)
tangent of x, where x is given in
radians
ATAN(x)
arctangent of x, where x is given
in radians
SQRT(x)
square root of x is returned

Type of
Argument(s)
real
integer
integer
real
integer
integer
real
real
real
real
real
real
real

10 If IREM is called as IREM (x/y), the remainder of x/y will be returned.
If the argument of IREM does not contain a division, the remainder of the
last integer division will be returned. Subsequent calls to IREM without a
division being performed will return the value 0. If a READ or WRITE is
executed after a division but before calling IREM, the value 0 will be
returned.

1~35

Table 1-3 (Cont.) Function Library

Function

Definition

IRDSW(O)

read the console switch register,
returning the decimal equivalence of the octal integer in the
switch register. The switch register can be set before executing the FORTRAN program,
or durirtg execution using the
PA USE statement.

Type of
Argument ( s)
integer

Floating Point Arithmetic
In general, floating point arithmetic calculations are accurate to
seven digits with the eighth digit being questionable. Subsequent
digits are not significant even though several may be typed to satisfy
a field width requirement. With the exception of the arctangent
function, which is accurate to seven places over the entire range,
results of function operations are accurate to six decimal places.11
The floating point arithmetic routines check for both overflow
and underflow. Overflow will cause the OVFL error message (or
FPNT if using 8K paper tape FORTRAN) to be typed and program execution will be terminated. Underflow is detected but will
not cause an error message. The arithmetic operation involved will
yield a zero result.
11 The arctangent function in 8K paper tape FORTRAN is accurate to six
decimal places for arguments whose absolute value is greater than .01. -

1-36~

DEVICE INDEPENDENT 1/0 AND CHAINING 1 :!
OS/8 FORTRAN provides for device independent, file-oriented,
formatted 1/0 through use of the device number 4 in the READ
and WRITE statements and several utility subroutines. These are
described below.

The I 0 PEN Subroutine
The subroutine IOPEN prepares the system to accept input
from a specified device when device code 4 is used in a READ
statement. IOPEN takes two arguments which are interpreted as
Hollerith strings. After a
CALL

IOPENCA,8)

any READ statement reading from device 4 will read from the file
specified by B (which must have the extension .DA) on the device
specified by A. For example:

c ALL

I 0 p EN ( I DTA 5 I ,

IN p uT I )

will prepare for input from the file DT AS: INPUT.DA

will prepare for input from the device FI. which, in this case, is a
non-file-structured device.
If the file and device names are input via READ statements
which use A format in their FORMAT statements, then A6 format
must be used. ((1 signs rather than spaces should be used to fill in
. 1~

The information described in this section is available only in OS/ 8
FORTRAN.

1-37

empty characters. For example, the following statements are contained in a program:
20
22

WRITE (1,20)
FORMAT C'ENTER FILE NAME')
READ Cl,22)FNAME
FORMAT CA6)
CALL IOPENC'DSK',FNAME)

The Teletype prints:
ENTER FILE NAME

and the user responds:
ABC@@@

The OOPEN Subroutine
The subroutine OOPEN prepares the system to send output to
a specified device when device code 4 is used in a WRITE statement. The arguments of OOPEN arc treated like those of !OPEN.
Future WRITE statements using device 4 write on the device and
file specified in the call to OOPEN. An error message is printed
if the program has previously issued a CALL OOPEN without
issuing a subsequent CALL OCLOSE. For example:
CALL OOPENC 'PTP' ,(,?!)

prepares device 4 to output on device PTP.
CALL OOPENC 'SYS',' LAOt:')

prepares device 4 to output to the file SYS: LADE.DA.
The OCLOSE Subroutine
The subroutine OCLOSE is called with no arguments. Its function is to terminate output on the output file opened by OOPEN.
If OCLOSE is not called after a file has been written, that output
file will never exist on the specified device.
·

The CHAIN Subroutine
A call to the subroutine CHAIN terminates execution of the calling program and starts execution of the core image on the system
device as specified by the argument to CHAIN. Variables in common storage are not disturbed. For example:
CALL CHAINC'PROG2')

causes the file SYS:PROG2.SV to be loaded and started. Notice
that PROG2 must be. compiled and stored on the system device as
" ..:ore image ( .SV) file in order to be successfully accessed.
The EXIT Subroutine
To return to the Keyboard Monitor from a FORTRAN program,
the EXIT subroutine is used, as follows:
CALL EXIT

DECTAPE I/O ROUTINES
RT APE and WT APE (read tape and write tape) are the DECtape read and write subprograms for the 8K FORTRAN and 8K
SABR systems. For the paper tape FORTRAN system, these subprograms are furnished on one relocatable binary-coded paper tape
which must be loaded into field 0 by the 8K Linking Loader, where
they occupy one page of core.
RT APE aI1d WT APE allow the user to read and write any
amount of core-image data onto DECtape in absolute, non-filestructured data blocks. Many such data blocks may be stored on
a single tape, and a block may be from 1 to 4096 words in length.
RT APE and WT APE are subprograms which may be called with
standard, explicit CALL statements in any SK FORTRAN or
SABR program. Each subprogram requires four arguments separated by commas. The arguments are the same for both subprograms and are formatted in· the same manner. They specify the
following:
1. DECtape unit number (from 0 to 7)
2. Number of the DECtape block at which transfer is to start.
The user may direct the DECtape service routine to begin
searching for the specified block in the forward direction

1-39

rather than the usual backward direction by making this
argument the two's complemen.t of the block number. For
additional information on this and other features the reader
is referred to the DECtape Programmer's Reference Manual (DEC-08-SUCO-D).
3. Number of words to be transferred ( 1 <N < 409,6) .
4. Core address at which the transfer is to start.
The general form is:

where n 1 is the DECtape unit number, n:! is the block number, n:~
is the number of words to be transferred, and n-i is the starting
address.
In 8K FORTRAN, an example CALL statement to RTAPE
could be written in the following format (arguments are taken as
decimal numbers) :

In this example, LOCA may or may not be in common.

As a typical example of the use of RT APE and WT APE, assume
that the user wants to store the four arrays A, B, C, and D on a
tape with word lengths of 2000, 400, 400, and 20 respectively.
Since PDP-8 DECtape is formatted with 1474 blocks (numbered
0-2701 octal) of 129 words each (for a total of 190,146 words) 1 \
A, B, C, and D will require 16, 4. 4, and 1 blocks respectively.

1 3 The block numbers used by RTAPE and WTAPE should not be confused
with the record numbers used by OS/8. An OS/8 record is 256 wordsroughly twice the size of a DECtape block. An RTAPE or WTAPE record
number is exactly twice the corresponding OS/8 record number. For example, to read the first segment of the OS/8 directory on DECtape # 5,
the statements:

DIMENSION IDIRC25R)
CALL RTAPFCS,?,,25~,IDIR)

would read Block 2 (OS/ 8 Block 1) of DECtape # 5.

1-40

Each array must be stored beginning at the start of some DECtape
block. The user may write these arrays on tape as follows:
~

CALL
CALL
CALL
CALL

WTAPEC0,1,2000,A>
WTAPEC0,17,400,B>
WTAPEC0,21,400,C>
WTAPEC0,25,20,D>

The user may also read or write a large array in sections by
specifying only one DECtape block { 129 words) at a time. For
example, B could be read back into core· as follows:

CALL RTAPEC~,17,258,BCl>>
CALL RTAPEC0,19,129,BC259))
CALL RTAPEC0,20,13,BC388>>

As shown above, it is possible to read or.· write less than 129
words starting at the beginning of a DECtape block. It is impossible, however, to read or write starting in the middle of a block.
For example, the last 10 words of a DECtape block may not be
read without reading the first 119 words as well.
A DECtape read or write is normally initiated with a backward
search for the desired block number. To save searching time, the
user may request RT APE or WT APE to start the block number
search in the forward direction. This is done by specifying the negative of the block number. This should be used only if the number
of the next block to be referenced is at least ten block numbers
greater than the last block number used. For e:x_ample, if the user
has just read array A and now wants array D, he may write:

CALL RTAPEC0,1,2000,~l
CALL RTAPEC0,-27,20,0l

The following section of a program demonstrates the use of
DECtape 1/0. Assume that values are already present on the
DECtape.
1-41

DIMENSION DATAC500J

50
100

110

NB=0
SUM=0·
DO 100 N=l,10
CALL RTAPE C1, -NR, 1500, DATA);
TEM=0·
DO 50 K=l,500
TEM=TEM+DATACK)
SUM=SUtv'.+TEM
NR=NR+2LJ
AMEAN=SUM/5000.,
WP.ITE Cl,~10) SUM, AMEAN
CALL EXIT
FORMAT C'SUM=',E15.7' MEAN=',E15.7///)
END

OS/8 FORTRAN LIBRARY SUBROUTINES 14
Table 1_-4 contains a summary of the OS/8 FORTRAN library
subroutines. This list describes the routines available under OS/8
FORTRAN, their functions, and other routines which must also
be present in order for them to be· used. The Subroutine Names
listed are the files which comprise OS/8 Source DECtape #3
(available from the Software Distribution Center upon request).
Table 1-4

OS/ 8 FORTRAN Library Subroutines

Entry
Points, Routines
or Defined That are
Subroutine External
PreName
Symbols requisites
JOH

Core
Requirements
(Pages)

'READ' FLOAT
'WRITE' UTILTY
'JOH'
.INTEGR

Function the
Routine
Performs
Handles Input
and Output
Conversion

H This table does not apply to 8K paper tape FORTRAN. The Subprogram Library for the paper tape version is available on two relocatable
binary paper tapes. Part 1 contains those subprograms used by almost every
FORTRAN/SABR program. The organization of the programs is described
in the SABR chapter of this manual.

1-42

Table 1-4 (Cont.) OS/8 FORTRAN Library Subroutines

Entry
. Points, Routines
or Defined That are
Subroutine External
PreSymbols requisites
Name

Core
Requiremen ts
(Pages)

Function the
·Routine
Performs

'FAD'
UTILTY
'FSB'
'FMP'
'FDV'
'STO'
'FLOT'
'FLOAT'
'FIX'
'IFIX'
'IFAD'
'ISTO'
'ABS'
'CHS'

Floating
Point Arithmetic Package

INTEGR
UTILTY 'OPEN'
'GENIO'
'EXIT'
'ERROR'
'CKIO'

FORTRAN Device Routines,
Error Exit,
Normal Exit

POWERS 'IFPOW'
'FFPOW'
'EXP'
'ALOG'

FLOAT
UTILTY
IPOWRS
INTEGR

Handles Numhers to
Floating
Powers

UTILTY
INTEGR 'IREM'
'JABS'
'DIV'
'MPY'
'IRDSW'
'CLEAR'
'SUBSC'

Integer Math
Package

FLOAT

1-43

Table 1-4 (Cont.) OS/8 FORTRAN Library Subroutines

Entry
Points, Routines
or Defined· That are
Subroutine External
PreSymbols requisites
Name

Core
Requiremen ts
(Pages)

Function the
Routine
Performs

TRIG

'SIN'
'COS'
'TAN'

FLOAT

Handles Sine.
Cosine. and
Tangent

ATAN

'ATAN'

FLOAT

Handles Arctangents

SQRT

'SQRT'

FLOAT
UTILTY

Handles Square
Roots

IPOWRS

'II POW' FLOAT
'FI POW' INTEGR

Handles Numbers to Integer
Powers

I OPEN

'IO PEN'. UTILTY
'OOPEN'
'OCLOS'
'CHAIN'

OS/ 8 DeviceIndependent
1/0, and
Chaining
Routines

RWTAPE 'RTAPE' UTILTY
'WTAPE'

OS/ Independent DECtape
1/0 Routines

MIXING SABR AND FORTRAN STATEMENTS 1r.
An S in column 1 of an input line identifies that line as containing SABR code. This feature is very useful for performing instructions which are undefined in the FORTRAN language. For
example:

rn_ Available only in OS/8 FORTRAN.

1-44

D IM EN S I ON M C 1 0 )

s
s
s
55 -

J=M C 1 )
. DO 55 K=?., 10
L=MCK)
TAD
\L
AND.
\LJ
DCA
\J
CONTINUE

This section of code will form the logical AND of M ( 1) through,
M( 10) in the variable J.
Notice that whenever a FORTRAN variable is used in a SABR
statement, the variable name is preceded by a backslash C"'-).
FORTRAN line numbers referenced in SABR statements, are also
preceded by a·· backslash for identification purposes. (A backslash
is produced by typing a SHIFT/L.)
Information on calling subroutines which are written in SABR
assembly language from a FORTRAN program may be found in
the SABR. ch~pter of this manual.

SIZE OF A FORTRAN PROGRAM ·
The maximum _size of any FORTRAN program is 36 octal or
30 decimal pages of code.
OS/8 can run FORTRAN programs in 8 to 32K of core. No
one program or subprogram can be longer than 4K, however.
The :user: ·can- estimate the size of his program as follows: Take
the amount of core available on the system (at least SK) and from
it subtract 4K for the linkage subroutines, external symbol table,
and I/O, math, error, and utility subroutines. From the remainder
subtract the amount of storage required for data. The remaining
space can be used to hold FORTRAN coding, at the rate of 50-70
FORTRAN statements per 1K of core.
One way to have a longer FOR TRAN program in core than is
usually possible is to divide a FORTRAN program into three
chained segments:
Segment I-inputs data into common storage
. Segment 2-·FORTRAN program for data processing
Segment 3-does output to desired device(s)
1-45

This gives two space advantages:
1. The entire program does not have to fit into available core,
only the largest segment.
2. If no 1/0 statements are used in th~ middle (computational)
segment, the 1/0 conversion routines will not be loaded with
that segment. Since these routines occupy over 11 OOrn words,
this technique allows the computational segment to be from
50 to 80 statements longer than a similar program contain ...
ing I/0 statements.
When chaining to a subroutine, the user must be sure he has com·
piled, loaded, and saved a complete runnable main pro¥ram on the
system device. This program is brought into core by the FORTRAN
CHAIN subroutine.
Information concerning using FORTRAN or SABR with the
interrupt on, or using PAL8 with SABR or FORTRAN can be
found in the OS/8 chapter of Introduction to Programming,

OPERATING INSTRUCTIONS
The Compiler, SABR Assembler, and Linking Loader are used
(in that order) to compile, assemble, and execute FORTRAN pro ...
grams. Throughout the following proc~dures, the Data Field
setting can be ignored since all system tapes, with the exception
of Linking Loader, have field settings coded on them.
Loading and Operating the Compiler
The following instructions for loading and operating the compiler
apply only to 8K paper tape FORTRAN. (OS/8 operating instruc"\'
tions are found in Introduction to Programming.)
~

1. Make sure the Binary Loader is in memory, assume field 1,
2. Place· the FORTRAN Compiler binary tape in the read~r.
3. Set Switches 6-8 == 00 I.
4. Press EXTD ADDRess LOAD.
5. Set Switch Register == 7777.
6. Press ADDress LOAD.
7. , If using a high-speed reader, d~press Switch Register bit 0.
8. Press CLEAR and CONTinue.
9. The FORTRAN Compiler has now been loaded. into mem~
ory by the Binary Loader. Parts of the compiler will load into
field 0 and field 1.

1-46

It is assumed that the programmer has written his main program
and possibly one or m~re subprograms, and that these source programs have been punched on paper tape in ASCII format. Remember that each source tape must have an END statement at the
end of the tape.
After the compiler has been loaded into memory, it is used to
translate each FORTRAN statement into one or more SABR assembler instructions. The compiler output will be punched in two
parts separated by approximately three feet of blank tape. The
first part (executable code) will be punched as the source tape is
read. The second part (variable storage and constants) will be
punched after the entire source tape has been read.
It may be desirable to suppress all compileroutput the first time
a particular program is compiled, simply to check for errors. To do
this it is necessary to load the compiler and then deposit 307 5 in
location 03 5 6 (field 0), prior to starting ,the compiler.

1. Set the console switches as follows: switches 6-8 = 001, and
switches 9-11 = 000.
2. Press EXTD ADDRess LOAD.
3. Place the FORTRAN program source tape in the reader,
and press the punch ON.
4. Set Switch Register = 1000 (the compiler may also be
started at location 5364 in field 0).
5. Press ADDress LOAD and CLEAR and CONTinue.
6. As soon as the compiler has typed out an identification number, it will begin compiling the user's program. The compiler
output will generally be several times the length of the FOR" source program.
TRAN
1

8K FORTRAN Errors
All compile time, assembly time, and execution time errors are
fatal (the program will not be further processed). For this reason
it is desirable to suppress punched output of the compiler and
assembler until the source program is believed to be correct.
Do not attempt to load or run a program which has assembly
errors. Do not attempt to proceed after an execution time error by
pressing CONTinue. Unpredictable results will be obtained in
either case.

1-47

COMPILER ERROR MESSAGES
When an error is encountered during compilation of a statement,
the incorrect statement and an error message are printed. Further
compilation of that statement is terminated, and output is suppressed for the rest of the compilation. The compiler, however,
will scan the remaining statements for errors, and will print an
error message for any errors found.
An example .of an error message follows:
A=B+M(6)+N<l)
MIXED MODE EXPRESSION

Note that an up arrow ( t) was printed directly below the incorrect statement. This indicates that the error occurred somewhere
between the point and the beginning of the statement. In some cases
the arrow may point directly at the illegal character or word. but
this cannot always be assumed.
If an error occurs in the middle of a series of continuation lines,
all remaining lines in that statement will be printed with the error
message ILLEGAL CONTINUATION.
The compiler does not print messages for certain errors. This
usually occurs due to one of three reasons:

1. Erroneous FORMAT statements or unbalanced DO statements-at compile time the processing of the FORMAT
statements is superficial and_ errors will not be detected until
execution.
2. No DIMENSION statement for subscripted variables-the
variable is treated as a function name and will not be detected
unless referenced. This can be checked by producing a loader
map or list of undefined external symbols. (OS/8 provides a
U option for producing a loader map, while this is available
in 8K paper tape FORTRAN as a switch option. See the
appropriate operating instructions.)
3. Undefined statement number-the compiler does not detect
undefined statement numbers. These will be caught during
assembly. Therefore, it is important to examine the assembly
symbol table for undefined symbols and statement numbers
before loading and executing the program. In OS/8
1-48

FORTRAN, if no symbol table printout is requested, the
message U AT \ I 0+0000 will occur where there is no
statement numbered 10.
Compiler error messages are self-explanatory:
ARITHMETIC EXPRESSION TOO COMPLEX
EXCESSIVE SUBSCRIPTS
ILLEGAL ARITHMETIC EXPRESSION
ILLEGAL CONSTANT
ILLEGAL CONTINUATION
ILLEGAL EQUIVALENCING
ILLEGAL OR EXCESSIVE DO NESTING
ILLEGAL STATEMENT
ILLEGAL STATEMENT NUMBER
ILLEGAL VARIABLE
MIXED MODE EXPRESSION
SYMBOL TABLE EXCEEDED
SYNTAX ERROR (usually illegal punctuation)
When the paper tape FORTRAN compiler has finished punching
both sections of tape it will halt. It may be restarted to compile additional programs by pressing CONTinue.
The paper tape FORTRAN compiler may be restarted at any
time by pressing HALT and resetting the console switches.
OS/8 FORTRAN contains the following error messages in addition to those listed above:
Message
Explanation

1/0 ERROR

A device handler has signalled
an .1/0 error.

NO ROOM FOR OUTPUT

The file FORTRN.TM cannot
fit on the system device.

SABR.SV NOT FOUND

The SABR Assembler is not
present on the system device.

NO END ST ATEMENT

The input to the compiler has
been exhausted.

COMPILER MALFUNCTION

The meaning of this message
has been extended to cover

1-49

various unlikely monitor errors.
SUBR. OR FUNCT. STMT.
NOT FIRST

FORTRAN detected a SUBROUTINE or FUNCTION
statement in the middle of a
computation.

OS/8 FORTRAN LIBRARY ERROR MESSAGES
During execution, the various library programs check for certain
errors and print error messages in the form:
XXXX

ERROR AT LOC NNNNN

where XXXX is the error code and NNNNN is the location of the
error. Table 1-5 summarizes the Library Error Messages.
Table 1-5

FORTRAN Library Error Messages

Error Code

Meaning

ALOG

The following errors are fatal and cause a return to the Keyboard Monitor.
Attempt to compute log of negative number.

IOER

One of the following has occurred:
1. Device independent input or output
attempted without /I or /0 options,
Refer to Chapter 9 of Introduction to
Programming
2. Bad arguments to !OPEN or OOPEN,
or
3. Transmission error while doing I/O.

CHER

File specified as argument to CHAIN not
found. on system device.

FMTl

Invalid Format Statement

FMT2

FMT3

The following input errors are fatal 'unless
input is coming from the Teletype, in which
case the entire READ statement is tried again.
Illegal character in I format.
Illegal character in F or E format.
The following errors do not terminate execution of the user's program.
1-50

Table 1-5 (Cont.) FORTRAN Library Error Messages

Error Code

Meaning

DIVZ

Division by zero-very large number is returned.

EXP

Argument to EXP too large-very large
number is returned.

OVFL

Floating point overflow-very large number
is returned.

FLPW

Negative number raised to floating point
power-absolute value taken.

SQRT

Attempt to take square root of negative
number-absolute value used.

FIX

Attempt to fix a number >2047; 2047 is
returned.

In addition, the error message:
USER ERROR 1 AT 00537

means that the user tried to reference an entry point of a program
which was not loaded.
To pinpoint the location of a library program execution error:
1. Determine, from the storage map, the next lowest numbered
location (external symbol) which is the entry point of the
program or subprogram containing the error.
2. Subtract, in octal, the entry point location of the program or
· subprogram containing the error from the location of the
error indicated in the error message.
3. From the assembly symbol table, determine the relative address of the external symbol found in step l and add that
relative address to the result of step 2.
4. The sum of step 3 is the relative address of the error, which
can then be compared with the relative addresses of the
numbered statements in the program.
1-51

Loading the SABR Assembler
Procedures for loading SABR and assembling a source program
are given below. See Appendix· A for instructions on use of the
Binary Loader. OS/8 SABR instructions are included in the OS/8
chapter of Introduction to Programming.)
1.
2.
3.
4.
5.
6.
7.
8.
9.

Make sure the Binary Loader is in memory, assume field I.
Set Switches 6-8 == 001.
Press EXTD ADDRess LOAD.
Set Switch Register == 7777.
Press ADDress LOAD.
Insert the SABR binary tape into the reader.
If using the high-speed reader, depress Switch Register Bit 0.
Press CLEAR and CONTinue.
SABR will now be loaded into memory by tht? Binary Loader.
Portions of SABR will be loaded into both Field 0 and 1.

Operating the SABR Assembler 1 H
In addition to being a stand-alone assembler, SABR also serves
as the second pass of 8K FORTRAN compilation. For this purpose
the use of SABR is slightly different from that described in the
SABR chapter of this manual. This difference in the operation <;>f
SABR is due only to the unusual format of the FORTRAN com..
piler output.
The compiler, in one pass, converts the user's FORTRAN
source program into a symbolic machine language program tape
containing standard PDP-8 mnemonics. However, the symbolic tape
produced by the compiler is not a standard format SABR language
tape. It is arranged as shown in the following figure:

s
L

A
D
E
R

R
T
R

MAIN PART
OF PROGRAM;
EXECUTABLE
CODE.

SYMBOL DEFINITIONS
COMMON, ARRAYS,
DATA AND
PROGRAM ENTRY
POINT.

E
N

A
R
A
T

~TRUE START
I

3 OF BLANK TAPE

Applies to 8K paper tape FORTRAN only.

1-52

p
A

T
R
A
I
L

The tape is arranged this way because the data at the end of the
tape cannot be inserted_ in the midst of the executable code, and
some of it which should be at the beginning of the tape is not
known until the pass is completed. Thus, the true start of the symbolic program is near the end of the symbolic tape preceded by a
segment of blank tape and followed by a PA USE statement.
To assemble such a tape with SABR and convert it into relocatable binary, one of three methods must be followed. The general
procedure is the same as that described in the SABR chapter but in
particular details it differs. The differences are covered by the three
methods explained below.
METHOD 1
Cut the symbolic tape produced by the compiler into two parts.
The cut should be made at the middle of the blank portion of tape
which separates the· executable code from the symbol definitions.
The section containing the symbol definitions (the latter part of the
tape) should be marked "Section l ," and the section containing the
executable code marked "Section 2."
The first pass through SABR creates the relocatable binary version of the user's program; at the end of this pass, the symbol table
may be typed and/ or punched. Pass 2 creates the listing. Section 1
should be inserted in the reader before assembly is begun.
It may be desirable to suppress all assembler output the first time
a particular program is assembled, simply to_ check for errors. To
do this it is necessary to load SABR and then deposit 53 70 in location 3165 (Field 0) before beginning step (1) below.
1.
2.
3.
4.
5.

Set switches 6-8 == 0, and switches 9-11 == 0.
Press EXTD ADDRess LOAD.
Set the Switch Register == 0200.
Press ADDRess LOAD, CLEAR and CONTinue.
SABR now types a sequence of two or three questions;
HIGH SPEED READER?
HIGH SPEED PUNCH?
LISTING ON HIGH SPEED PUNCH?

These questions must be answered with "Y" if the answer
is "yes." Any other answer is ·assumed to be "no." The
third question is typed only if the second is answered "Y."
If the third is answered "Y," both the symboLtable and the

' 1-53

listing will be punched on the high-speed paper tape punch.
Othe;rwise,. they are typed on the teletypewriter. lncidentaily,
the user need not wait for the full question to be typed be ...
fore responding.
6. As soon as SABR has echoed the user's response to the last
question, the punch device and, if it is being used, the Tele- '
type reader, should be turned on. If using the low-speed
reader, the error message E indicates that the user has waited
too long before turning the reader on and will have to start
over.
7. At this point, pass l begins. SABR reads the source tape and
punches the binary tape. After the binary tape has been
completed SABR will type or punch the program symbol
table.
8. If the source tape is in several sections (separate tapes with
PAUSE at the end of all except the last), SABR will halt
at the end of each section. At this point the user should insert the next section in the reader and then press CONTinue.
9. At the end of Pass 1 SABR halts.
10. If the user desires an assembly listing, he should now reposition the beginning of the source tape in the reader and
press CONTinue.
If the listing is going to be punched on the high speed
punch, the user may want to list the symbol table (at the
end of the binary relocatable type) before beginning Pass 2.
11. At the end of Pass 2 SABR will again halt. It may be re ...
started for assembling another program by pressing CONTinue.
12. SABR Jnay be restarted at any time by pressing HALT, setting the switch register ==0200, pressing ADDress LOAD
·and CLEAR and CONTinue. However, Pass 1 must always
be repeated.
METHOD 2
The user may avoid actually cutting the symbolic tape by manipulating the tape as if it were two parts. The tape should initially
be inserted in the reader with the separator blank tape over the
read-head. When SABR halts at the PA USE statement at the
physical end of tpe tape, the user should reposition the tape, putting
the physical beginning of the tape in the reader. Then press

1-54

CONTinue. The assembly pass will end at the separator blank tape
code. The assembly listing can be produced in a similar manner,
pressing CONTinue to start the listing pass.
METHOD 3
The third method requires SABR to pass the symbolic tape two
times for each pass of the assembly. However, it allows the tape
to be inserted at its physical beginning. It is based on the fact that
a symbolic tape output by the FORTRAN Compiler has as its
physical first line the special pseudo-op, FORTR. This pseudo-op
has no effect except when a symbolic tape output by the compiler
is assembled using this third method.
1. Insert the symbolic tape in the reader at its physical beginmng.
2. Start SABR as usual.
3. Sensing the FORTR statement as the first line, SABR ignores all further data until after it passes over the END
statement. SABR then begins the actual assembly by processing the symbol definitions, etc., which are at the latter
end of the tape.
4. Then SABR halts at the PA USE statement which is at the
physical end of the tape. At this time the user should reposition the symbolic tape in the reader at the physical
· beginning of the tape, and then press CONTinue. SABR
now assembles the executable code portion of the tape in the
normal way.
5. If the user desires an assembly listing, he should proceed
as in Step 10 of Method 1 after SABR finishes the assembly
pass.
The Linking Loader
(The OS/8 Linkin_g Loader is described in Introduction to Programming. For additional details concerning the 8K System Linking
Loader, the reader is referred to Chapter 2 of this manual.)
Relocatable binary program tapes produced by SABR assemblies
and the FOR TRAN /SABR Library programs are loaded into memory by the SK System Linking Loader. The Linking Loader is capable of loading and linking a user's program and subprograms in
any fields of memory, and has options which give storage maps
and core availability.

1-55

LOADING THE LINKING LOADER 17
The Linking Loader must be loaded into the highest available
field of memory.
l. Make sure the Binary Loader is in memory, for example, in
field m.
2. Let h represent the number of the highest field in the user's
configuration.
3. Set the console switches as follows:
Switches 6-8 = m, and switches 9-11 ----: h.
4. Press EXTD ADDRess LOAD.
5. Set the Switch Register == 7777.
6. Press ADDress LOAD.
7. Place the binary paper tape of the Linking Loader in the
reader.
8. If using a high-speed reader, depress switch register Bit 0.
9. Press CLEAR and CONTinue. The Linking Loader will now
be loaded into memory.

LOADING RELOCATABLE PROGRAMS.
The Linking Loader is used to load the user's relocatable programs and SK Library subprograms as outlined below.

NOTE
The program or subprogram which uses the
largest amount of common storage should
be loaded first.
1. After the Linking Loader has been loaded into the highest
memory field, h, the user should set the console switches
as follows: Switches 6-8 == h and switches 9-11 == h.
2. Press EXTD ADDRess LOAD.
3. Set the Switch Register == 0200.
4. Press ADDress LOAD.
5. Place the relocatable binary tape for the first program to
be loaded in the reader. Position the tape with leader code in
the reader.
6. Set $Witch register to 0000. Then, if loading via the Teletype reader is required, raise switch register bit 6. If the
user does not have a high-speed punch, he should raise
17 Applies to SK paper tape FORTRAN only.

1-56

switch register bit 7. Finally, set switch register bits 9-11
to the number of the field into which the first program or
subprogram is to be loaded.
SWITCH REGISTER

I~ ~ I
I

1· I

LLsTORAGE MAP
CORE PAGES

.LL

1; I : 1
·

~ I 1~ I \ I
1

LOAPING FIELD

PUNCH (TELETYPE)
READER (TELETYPE)

Example:
If the user wishes to load his first program into field 3, and
if he has no high-speed 1/0 device, then he should set the
switch register to 0063 before the next step.

7. Press CLEAR and CONTinue;
· 8. The user's relocatable binary program will now be loaded.
When loading is completed, the Linking Loader halts.
9. The user may now either load another program or select
one of the options in steps 1 I and 12.
10. To load another program, insert the program relocatable
binary tape in the reader, set switch register bits 9-11 to
the number of the field the program is to be loaded into,
and then press CONTinue.
11. To select the Core Availability option, set switch register
bit 0 ~ 1, and press CONTinue.
12. To select the Storage Map option, set switch register bit 1 ==
1, and press· CONTinue.
13. The user may continue loading more programs as in step
10 after using either of the options.
14. The Linking Loader may be restarted via the console switches
at location 7200 (in the highest field, where the Linking
Loader resides) .
Executing the FORTRAN Program 18
Determine the starting address of your main program by using
the Linking Loader Storage Map option. The address will be
typed in the form:
MAIN dnnnn
18

Applies to SK paper tape FORTRAN only.

1-57

Set switches 6-8 = d, and switches 9-11 == d.
Press the EXTD ADDRess LOAD.
Set Switch Register== nnnn.
Turn on paper tape punch and/or put data tape in reader
as required.
5. Press ADDRess LOAD, CLEAR, and CONTinue. Program
execution will begin.
DEMONSTRATION PROGRAM
This program computes the factorials of the even integers from
2 through 34. The MAIN program calls the subprogram to perform
the computation. The sourc~ programs were created using the
Symbolic Editor, listed on the Teletype for inclusion here, and
punched on the high-speed punch. They were then compiled using •
the 8K paper tape FORTRAN Compiler on a PDP-8/I with 8K
words of core memory, and a high-speed reader/punch.
This demonstration may also be run under the OS/8 Operating
System. The only differences the user will note are that under OS/8
the operating process is considerably shorter, and the output contains leading zeros before the decimal point. A demonstration program is also contained in the OS/8 chapter of Introduction to Programming.
1.
2.
3.
4.

10
60
C
1
2

3
4
5

FORTRAN DEMONSTRATION PROGRAM
DIMENSION AC35)
DO 10 N=2,34,2
ACN>=FACTCN>
~RITE Cl,60>N,ACN>
STOP
FORMAT CI3,'! = ',El4.7>
END
FORTRAN FUNCTION TO COMPUTE FACTORIALS
FUNCTION FACTC N >IF CN-34> 1,5,5
IF CN> 2,4,2
M=N-2
FACT=N
DO 3 K= 1, M
C=N-K
FACT=FACT*C
RETURN
FACT=l·
RETURN
·\.i.'R IT E

C1 , 6 > N

FACT=0.
RETURN
FORMAT CIS,'! EXCEEDS CAPACITY OF PROGRAM·'·>
END

1-58

The FORTRAN Compiler is loaded, and the Compiler types
out an identification label such as the following:
PDP-8 FORTRAN DEC-08-A2Bl-4

The source programs are compiled and tapes of the compiled pro ..
grams are punched on the high-speed punch.
The SABR Assembler is loaded next. The tapes prepared by the
Compiler are assembled, and the symbol tables listed on the Teletype:
PDP-8 SABR DEC-08-A2D2-16
HIGH SPEED READER? Y
HIGH SPEED PUNCH? Y
LISTING ON HIGH SPEED PUNCH? N

CKIO
FACT
IOH
ISTO
MAIN
OPEN
SUB SC
WRITE

\A
\N
\10
\60
tA
tB
tC
tD
tE
tF
tG

0000EXT
0000EXT
0000EXT
0000EXT
0352EXT
0000EXT
0000EXT
0000EXT
0510
0200
0351
0425
0477
0361
0471
0410
0447
0462
0474
0510

1-59

HIGH SPEED READER? Y
HIGH SPEED PUNCH? Y
LISTING ON HIGH SPEED PUNCH? N

FACT
FAD
FLOT
FMP
!OH
OPEN
STO
\.JRITE
(0

\C
\FACT
\K

\M
\N
\l

\2
\3

\4
\5
\6
J3
]6

tA
tB
tC
tD

0220EXT
0000EXT
0000EXT
0000EXT
0000EXT
0000EXT
0000EXT
0000EXT
0474
0205
0201
0204
0200
0472
0254
0264
0334
0357
0406
0447
0213
0210
0310
0351
0422
0472

The Linking Loader is loaded. The FORTRAN /SABR Library
programs and the binaries created by the SABR Assembler are
loaded into core in fields 0 and 1; the switch register is set appropriately, and a memory map is typed. (In this case all the Library
programs have been loaded-this is not necessary; if the user
wishes to determine which Library programs his program will use,
and how much core must be available, he may do so by using the
memory map option and loading the appropriate programs into any
fields available.)

1-60

PDP-8 LINKING LOADER DEC-08-A2C3-07
READ
WRITE
!OH
SET ERR
ERROR
TTYOUT
HS OUT
TTY IN
HSIN
FDV
CLEAR
IFAD
FMP
ISTO
STO
FLOT
FAD
DIV
IREM
FSB
FLOAT
FIX
IFIX
CHS
ABS
IABS
MPY
IRDSw
OPEN
CKIO
EXIT
CLRERR
SUB SC
IIPOW
IFPOV.:
FI POV.;
FFFOW
EXP
ALOG
SQRT
SIN

cos
TAN
ATAN
MAIN
FACT
0015
0010

10271
10302
12142
15200
15303
15027
15055
15000
15045
13 7 11
14227
14116
13623
14061
13444
14153
13010
14445
14616
13000
14034
13510
13556
14211
14636
14670
14400
14713
15125
1512 1
15142
15231
01000
01600
01662
01676
02050
01452
01347
02211
02673
026E3
02461
03057
03552
04020

1-61

Finally the starting address of the program is determined from
the memory map (MAIN 03552), and execution is started at this
location. The output is typed:
2
4
6
8
10
12
14
16
18
20
22
24
26
28
30
32

.2000000E+01
.2400000E+02
·7200000E+03
.4032000E+05
.3628800E+07
·4790016E+09
.8717829E+ll
.2092279E+14
·6402374E+16
.2432902E+l9
.1124001E+22
.6204484E+24
.4032915E+27
.3048883E+30
.2652529E+33
.2631308E+36
34! EXCEEDS CAPACITY OF PROGRAM.
34! =
.0000000E+00

End of program output.·
STATEMENT AND FORMAT SPECIFICATIONS

Tables 1-6 and 1-7 summarize the statements and format specifications available in 8K FORTRAN.
Table 1-6

STATEMENT
COMMENT

Statement Specifications
FORM 1 ~ 1

WHERE

"C" in column 1

columns 2 through 80
will be ignored.

CONTINUE

control goes to next
statement.

ARITHMETIC

v=e

variable name=
expression.

GOTO

GOTOn

n is a statement number.

GO TO (n,, ... ,nm), i

I ~ i ~ m and control
goes to statement ni . i is
a nonsubscripted integer
variable.

rn R or P indicates a required or prohibited statement number. N indicates
a nonexecutable statement.

1-62

Table 1-6 (Cont.) Statement Specifications
STATEMENT

FORM

IF (E) n1, n2, na

WHERE
Il1
control goes to n2 if
Ila
:::;_;

expression E

PAUSE

DO n i=mi, mz, ma

repeated execution
through statement n
beginning with i=m1,
incrementing by ma,
while i is less than or
equal to m2. m's and i
may not be subscripted.

DO n i=mi, m2

Iha assumed to be 1.

PAUSE

temporary halt, resumed
by CO NTinue key.

PAUSE n

octal equivalent of the
integer n displayed .

STOP

must be used to halt
execution of a main
program.

STOP n

octal equivalent of the
integer n displayed.

END

an END statement at the
end of a subprogram
tells the compiler there
is no more program.

READ (d, f) 1
WRITE ( d, f) 1

d is device number, f
is a FORMAT statement
number and 1 is list of
variable names separated
by commas.

•

STOP

END

READ
WRITE

FORMAT

FORMAT (k1 , ... , ku) k's are format specifications

COMMON

COMMON a, b, ... , n a , ... , n are nonsubscripted variable names

DIMENSION

DIMENSION
a 1 (k1) , ... , a 11 (k 11 )

1-63

a's are array names and
k's are maximum
subscri p ts.

T~ble l-6 (Cont.) Statement Specifications
',

STATEMENT

FORM

WHERE

FUNCTION

FUNCTION name
(a, .... , an)

a's are dummy arguments
and name must be
defined as a variabJe
containing the value of
the function.

SUBROUTINE

SUBROUTINE name
(a, •.... a 11 )

a's are dummy arguments
and name may not
appear elsewhere in
the subroutine.

CALL name

a's are actual arguments
of a subroutine and may
be expressions.

CALL

(a1 , ... ,au)

RETURN

for subroutines, contro]
returned to statement
following CALL. For
functions, evaluation of
expression in caJling program is resumed using
value of the function.

EQUIVALENCE NP

EQUIVALENCE

v's are variables or subscriµted array names. -

(v1 ' ... 'vu) ' ... '
(vm, ... 'v11)

Table 1-7 -FORMAT Specifications
KIND

FORM

WHERE

Jnteger

rlw

r 1s the repetition count; w is total
field width in characters.

Floating Point
(Decimal)

rFw.d

r 1s the repetition count, w is field
width including sign and decimal point,
and d is number of characters to right
of decimal point.

Exponential

rEw.d

r 1s the repetition count, w 1s field
width including sign, (a leading zero
in 05/8 FORTRAN), decimal point,
and d is the number of characters in
exponent.

Alphanumeric

rAw

r 1s the repetition count, w 1s fieid
width.

l-64

Table 1-7 (Cont.) FORMAT Specifications
KIND

FORM

WHERE

H (Hollerith
or Literal)

nHcharacters
'characters'

n is total number of characters includ·
ing spaces following H. Parentheses in
each format statement must balance.
Characters enclosed within single
quotes (SHIFT/7) are also printed.

Parentheses

n (specification)

format specification in parentheses is
repeated n times.
indicates beginning of a new data
record.

Carriage
Control
Blank or Skip
Fields

n blanks (spaces are introduced into
an output record or n characters
skipped in an output record).

STORAGE ALLOCATION
Representation of Constants and Variables
INTEGERS
Integers are each allocated one m(lchine word. They are represented in two's complement bi~ary .

Io 1
sign

111
Two's complement magnitude
/

Positive numbers in two's complement binary are represented as
straight binary with the first bit zero.

10 11 111 111 1111
37778 = +204710, the largest positive integer.
Negative numbers are represented by replacing each 0 bit with
a 1 and each 1 bit with a 0, then adding 1 to the binary result.
+1 is

Io oo ooo ooo 0011
-1 is

~ 11 111 111 11o)+1 = 11 11 111 111 111J=77778

The largest negative number is -2048 which is represented by
4000 8 or

11 oo ooo ooo ooo)
1-65

REAL NUMBERS
· Real numbers are each allocated three machine words. They
are represented as a binary mantissa multiplied by 2 raised to a
binary exponent:
Word 1

lo
sign

111

8 9

1
exponent

mantissa

Word 2

11
mantissa

Word 3

11
mantissa

The sign of the number is bit 0 of word 1 (0=+, 1=~ ). The
value and · sign of the exponent are obtained by subtracting
1 000 000:! (or 200 8 ) from bits 1 through 8 of word 1.
Example 1
1

100 000 001 100

-0-0Sign:
h
Exponent: 1G 000 001 :!
Mantissa: . 100:!
Exponent = 20 ls - 200s == 18
Mantissa = .48
No.= -.4 8 x 2 8 1
=-Vi X2=-l

1-66

Example 2
010 000 101 100
-0-

-0Sign:
02
Exponent: 10 000 lOh
Mantissa: .b
Mantissa = .4s
Exponent= 205s-200 8 =5 8
No.= As X 2s5
= 1h x 32 = 16

Storage of Arrays
Array variables are stored in core according to ANSI FORTRAN
Standards, in columns and from top to bottom. For example, the
array IJ:
DIMENSION

I JC 5)

if started at location 0705 would be stored:
01

_____

11
_....... 0705

IJ (1) ...,._..,._.
IJ (2)
IJ (3)
IJ ( 4)
IJ (5)

The real array, T:
DIMENSION TC3)

1-67

070£
0707
0710
0711

starting in location 0612 would appear:
01
T ( 1)

0612
....-----------ti 0613

..----------t 0614
T (2)
0615
......----------t 0616
0617
T ( 3) ------------t 0620
.,.___ _ _ _ _----. 0621
0622
Two-dimensional arrays are stored as shown below:
DIMENSION

IC4,2)

. l (1, 1) ..,..__ _ _ _ _ _---t 0566
I (2, 1)
0567
I (3, 1)
0570
I ( 4, 1)
0571
I (1, 2)
0572
1(2,2)
0573
1(3,2)
0574
1(4,2)
0575
In the array A(M(J,K) ), Mis a two-dimensional integer array
stored as indicated in the preceding illustration. No element of M
may be less than 1.
If the element M ( 3, 4) contains the integer 7, then A ( M ( 3, 4) )
will be evaluated as A(7). The largest integer stored in M must
not exceed the dimensions of A.
REPRESENTATION OF N-DIMENSIONAL ARRAYS
Although arrays of more than two dimensions are illegal, the
values of the subscripts of larger arrays may be calculated by using
the following algorithm:
il+D1 * (i:!-1 )+D1 *D:!(b-1 )+ ... D1 *D;! .. .DuOu-1)

where the subscript values are i1 , i:! ... i11 in an array whose dimensions are D1, D:! .. .Du.
1-68

Subprograms may be written to compute and insert subscript
values in such illegal arrays. For example, in an array A(3, 4, 5),
the following subprogram inserts the .value of element A (N 1, N2,
N3):

DIMENSION ARRAY <60)
READ <1,5) Nl,N2,N3,VALUE
I=Nl +3*<N2-1 )+3*4*<.N3-1)
ARRAY< I) =VALUE
FORMAT <3Il,F5.3)
END

Common Storage Allocation
Common storage begins in absolute . location 200 in field 1.
Variables are assigned locations in the common storage area in
ascending order as they appear in COMMON statements.

For example:
COM'fYiON A, LT, K

DIMENSION A<2,2),J(4)

would be stored as follows:
200

201

A(l,1)

202
A(2, 1) ..,______,

__________________ 203
204
205

206
A(l, 2)

207
210
....__ _ _ _ _ _ _ _- - I 211
~--------------------i

A(2, 2)

212
1----------------------t
J (1) ..._____________ 213
214

J(2)
215
J(3) 1---------~ 216

217

J(4)

K 1--------------------~ 220
1-69

NOTE
K does not appear in the DIMENSION statement.

If another subprogram defines a variable in common, such as
the following:
CO!":MON .J
DIMENSION JCS)

J ( 1) through J ( 5) will be assigned to locations 200 through 204
respectively, thus overlapping the variables A ( 1, 1 ) and A ( 2, I ) .
The Loader is not aware of this, therefore it is advisable to make
COMMON statements identical in all subprograms in which they
appear.
However, the statements:
COMMON DUMMY,J
DIMENSION DUMMYC2,2),JC4)

would not produce overlapping and could be used in subprograms.
In the example above, DUMMY is an arbitrary variable which
need not be used in the subprogram.

IMPLEMENTATION NOTES
Implied DO Loops
8K FORTRAN (paper tape version) does not have implied
DO loops in READ and WRITE statements. However, a simple
way to circumvent this restriction has been implemented. Normally
a CR/LF is produced at the end of each WRITE statement.' The
CR/LF can easily be suppressed by terminating the WRITE statement with a comma. The CR/LF can be generated explicitly in
one of two ways:
1. By using a WRITE ( d, f) instruction.
2. By using a FINI pseudo instruction.
----

The second method is more efficient since it generates only four
words of code, whereas the first method will generate somewhat
more than that. For example, the following statements:

1-70

DO 10 J= 1, M

10
20

WRITE Cl,20> CACJ,K>,K=l,N>
FORMAT Cl0F7·3>

which are not allowed in 8K paper tape FORTRAN, could be
written as follows:
DO 1 5 J= 1 , M
DO 10 K== 1, N

10
15

WRITE Cl,20> ACJ,K>,
WRITE Cl,2~>
FORMAT CF7·3>

. or
DO 1 5 J= 1 , M
DO 10 K=l,N
10

WRITE Cl,20> ACJ,K>,
FINI
FORMAT CF7.3>

The second method is preferred for more efficient utilization of core
memory. Note that it is not necessary to specify a repetition count
in the FORMAT statement since the 1/0 handler initializes itself
to the beginning of the FORMAT statement each time the WRITE
statement is executed.
The preceding comments apply as well to READ statements.
These methods are also useable in OS/8 FORTRAN, although
the implied DO loop is preferred.
FORMAT Handling
For more complicated FORMAT handling the following technique can be used. For example:

WRITE Cl,20> CACK>,K=l,N>
FORMAT CF7·2,2E15·6>

which is not legal in 8K paper tape FORTRAN, could be written
as follows:
(comma suppresses CR/LF)

10
20

WR I TE C1 , 2 0 >,
DO 10 K::d,N
CALL IOHCACK>>
FINI
FORMAT CF7•2,2El5.6>

1-71

In the example above, the statement WRITE ( 1, 20), generates
the following assembly code:
CALL2,WRITE
ARG
ARG

Cl
\20

The statement CALL IOH (A(K)) will generate code to call the
subscripting routine SUBSC and will then generate the following
code:

CALL 1, IOH
ARG. [0

, where [0 is a temporary location generated by the compiler. Finally
the FINI pseudo instruction will generate the following:
CALL 1, IOH
ARG 0

which will cause execution of the WRITE statement to be completed.
Although only WRITE statements have bee11 shown in the previous examples, the same techniques apply equally to READ
statements. To read in an array of arbitrary size, one might use the
following FORTRAN IV statements:
15
100

DO 15 I= 1, M
READ CID,100> CACI,J>,J=l,N>
FORMAT <Fs.2,Fs.0,2Fs.2,2Fs.0>

This will not work with SK paper tape FORTRAN, but the correct
results can be obtained using the following:
DO 15 I=l,M
READ

CID, 100)

DO 10 J= 1, N
10
15
100

CALL IOHCACI,J>>
FINI
FORMAT CFs.2,Fs.0,2F's.2,2F5·0)

1-72

If desired, these methods may also be used with OS/8 FOR.
TRAN.

Special I/ 0 Devices
I/O can be performed on devices other than Teletype and highspeed paper tape reader and· punch in several different ways:
1. If it is desired to use other devices in place of the high-speed
paper tape. reader and punch, rewrite the UTILTY library
subroutine defining the entry points for the desired input and
~ output devices as HSIN and HSOUT respectively. The source
tape for the Utility subroutine is available from the Program
Library and is very short. Refer to Chapter 2 for more
information. (This applies only to 8K paper tape FORTRAN).
2. If it is desired to input or output on a special device but not
in ASCII format-write a subroutine to handle the particular
device in the SABR assembly language. For more information refer to Chapter 2.
3. If it is desired to add devices which can be used in addition
to those allowed with READ and WRITE statements, then
edit part I of the Library Subroutine IOH. New entries must
be made in the device transfer table at the beginning of
IOH. Copies of this source tape and listings of the library
subroutines are available from the Software Distribution
Center. The service routines for the additional 1/0 devices
must be written in SABR assembly language and can then
be assembled along with the revised version of IOH. (This
applies only to 8K paper tape FORTRAN.)
4. Programs written in SABR language can call PAL subroutines in various ways:
a) A JMS 7000 instruction will call a PAL program which
starts at location 7000 in the same memory field.
b) A CONTINUE (or PAUSE) statement might be inserted
in the user's FORTRAN program. Then JMS to the
PAL subroutine may be inserted using the switch regis.ter.
It is possible to load any size PAL III program linkage with an
SK FORTRAN program by merely dimensioning an integer

1-73

variable to the proper size for the PAL III program. This offc~s two
advantages: virtually unlimited size. programs in PAL I I I can be
linked to 8K FORTRAN main programs, and none of the library
routines are disturbed by this linkage.
Extra devices may be added to OS/8 FORTRAN by modifying
the OS/8 FORTRAN Library routine GENIO. Only three more
devices may be added, however, and these rnust have device numbers of 10, l 1, and 12 respectively.

1-74

chapter 2
sabr assembler
SABR (Symbolic Assembler for Binary Relocatable programs)
is an advanced, one-pass assembler producing relocatable binary
code with automatically generated page and field linkages. It sup. .
ports an extensive list of pseudo-operations which provide, among
other facilities, external subroutine caJJing with argument passing
and conditional assembly.
A SABR program may call routines from a large library of sub~
routines and functions; these are loaded together with the SABR
program by the Linking Loader. In an optional second pass, SABR .
produces an octal/ symbolic listing of assembled programs.
The relocatable binary tape produced by a SABR assembly is
loaded into core for execution with the 8K Linking· Loader. SABR
and the Linking Loader are also incorporated in the OS/8 Oper-ating System (see Chapter 9 of Introduction to Programming) and
the 8K FORTRAN Operating System.
With the exception of their pseudo-operators, SABR and the
PAL assembly languages share a common subset of instructions;
the information contained in Chapters 1-5 of Introduction to
Programming is prerequisite to the use of SABR.
In particular, SABR features include;
SABR produces relocatable binary code;
SABR is _page and field independent-·field settings and links are
automatically generated, thus alleviating the programmer's need to
consider page boundaries, and simplifying the development of pro ..
grams greater than 4K;
SABR programs are loaded with the 8K Linking Loader and use
run-time linkage routines provided by- the Loader.
In general; a programmer might use SABR if he wants to write

2-1

a program quickly without regard to page boundaries, and if he is
not primarily concerned with program size. The programmer must
also use SABR if he wants to write subroutines that can be called
from a FORTRA_~ program.
SABR can be run on any PDP-8 series computer with at least
8K of core" storage and a Teletype. A high-speed paper tape
reader I punch is recommended.
The Character Set

ALPHABETIC
In addition to the letters A through Z, the following are con...
sidered by SABR to be alphabetic:
[ left bracket
] right bracket
"- back slash
t up arrow
NUMERIC
SABR recognizes the numbers:

0-9
SPECIAL CHARACTERS
The following printing and non-printing characters are legal:

I
(

"
#

Comma
Slash
Left parenthesis
Quote
Minus sign
Number sign
RETURN
(carriage return)
Semicolon
LINE FEED
FORM FEED
SPACE
TAB
RUBOUT

delimits a symbolic address label
indicates start of a comrrle'nt
indicates a literal
precedes an ASCII constant
negates a constant
increases value of preceding sym..;
bol by one
terminates a statement
terminates an instruction
ignored
ignored
separates and delimits items on
the statement line
same as space
ignored
2-2

All other characters are illegal except when used as ASCII
constants following a quote ("), or in comments or text strings.
Legal characters used in ways different from the above, and all
illegal characters, cause the error message C (Illegal Character) to
be printed by SABR.

Statements
SABR symbolic programs are written as a sequence of statements and are usually prepared on the Teletype, on-line, with the
aid of the Symbolic ~ditor program. SABR statements are virtually
format free. Each statement is terminated by typing the RETURN
key. (Editor automatically provides a line feed). Two or more
statements can be typed on the same line using the semicolon as a
separator.
A statement line is composed of one or all of the following elements: label, operator, operand and comment, separated ~y spaces
or tabs (labels require a following comma). The types of elements
in a statement are identified by the order of appearance in the line
and by the separating or delimiting character which follows or
precedes the element.
Statements are written in the general form:
label,

operator

operand

/comment (preceded by slash)

SABR generates one, or possibly more, machine (binary) instructions or data words for each source statement.
An input line may be up to 72 10 characters long, iµcluding
spaces and tabs. Any characters beyond this limit are ignored.
The RETURN key ( CR/LF) is both an instruction and a line
terminator. The semicolon may be used to terminate an instruction
without terminating a line. If, for example, the programmer wishes
to write a sequence of instructions to rotate the contents of the,
accumulator (AC) and, link (L) six places to the right, it might
look like this:

RTR
RTR
RTR

2-3

Using the semicolon, the programmer may place all three RTR's on
a sipgle line, separating each RTR with a semicolon and terminating the line with the RETURN key. The preceding sequence of
instructions could then be written: RTR;RTR;RTR

(terminated with the RETURN key)

This format is particularly useful when creating a list of data:

020Vl
0201
0202
0203

0020
0050
7750
0062

LIST,

20;50;-30;62

Null lines may be used to format program listings. A null line
is a line containing only a carriage return and possibly spaces or
tabs. Such lines appear as blank lines in the program listing.
LABELS
A label is a symbolic name or location tag created by the programmer to identify th_e address of a statement in the program.
Subsequent references to the statement can be made merely by
referencing the label. If present, the label is written first in a statement and terminated with a comma.
0200
0201

0000
1200,

SAVE,
.ABC,

0
TAD. SAVE

SAVE and ABC are labels referendng the statements in location
0200 and 0201, respectively.
OPERATORS
An operator is a symbol or code which indicates an action or
operation to be performed, and may be one of the following:
1. A 0irect or indirect memory reference instruction
2. ~n operate or IOT microinstruction
3. A pseudo-operator
All SABR operators, microinstructions and memory reference
instructions are summarized in Appendix C.
2-4

OPERANDS
An operand represents that part of the statement which is manipulated or operated upon, and may be a numeric constant, a Jiteral
or a user-defined address symbol.
In the example last given, SAVE represents an operand.

Constants
Constants are data used but not changed by a program and are
of two types: numeric and ASCII. ASCII constants are used only
as parameters. Numeric constants may be used as parameters or as
operand addresses, for example:
0200

1412

.TAD

Constant operand addresses are treated as absolute addresses,
just as a symbol defined by an ABSYM statement (see Symbol
Definition). References to them are not generally relocatable,
therefore, they should be used only with great care. The primary
use of constant operand addresses is to reference locations on page
_O (see Linkage Routine Locations for free location~ on page 0 of
each field). All constant operand addresses are assumed to be in
the field into which the program is loaded by the Linking Loader.
Constants may _not be added to or subtracted from each other or
from symb.ols.

Numeric Constants
A numeric constant consists of a single string of from one to
four digits. It may be preceded by a minus sign ( - ) to negate the
constant. The digit string will be interpreted as either octal or
decimal according to the latest permanent mode setting by an
OCT AL or DECIM pseudo-operator (explained under Assembly
Control). Octal mode is assumed at the beginning of assembly.
The digits 8 and 9 must not appear in an octal string.
0200
020 1

5020
7 57 5

0 20 2

0120

5020
-20 3

DEC IM
80

ASCII Constants
Eight-bit ASCII val~es may be created as constants by typing
the ASCII character immediately following a double quotation
2-5

marks ("). A minus sign may be used to negate an alphabetic constant. The minus sign must precede the quotation mark.
0200
02(7) 1
0202

0273
74.77
0207

" ,.
-"A

/-301

/BELL FOLLOWS "

The following are illegal as alphabetic constants: carriage return,
line feed, form feed and rubout.

Literals
A literal is a numeric or ASCII constant preceded by a left
parenthesis. The use of literals provides a special and convenient
way of generating constant data in a µrogram. The value of the
literal will be assembled in a table near the end of the core page on
which the instruction referencing it is assembled. The instruction itself will be assembled as an appropriate reference to the location
where the numeric value of the literal is assembled. Literals are
normally used by TAD and AND instructions, as in the following
examples:
0200
0 20 1
0202

0376
1375
1374.

0374.
0375
0376

0303
7730
0777

AND
TAD
TAD

C777
C-50

C"C

The numeric conversion mode is initially set to octal, but is controllable with the DECIM and OCT AL pseudo-operators. This
mode can be changed on a local basis by insertin'g a D ( decim~l)
or a K (octal) between the left parenthesis and the constant. For
example:
( D3 2 becomes 0040 (octal)
(K-32 becomes 7746 (octal)
This usage is confined only to the statement in which it is found
and does not alter the prevailing conversion mode.
A literal may also be used as a parameter (i.e., with no operator). In this case the numeric value of the literal is assembled as

2-6

usual in the literal table near the end of the core page currently
being assembled, and a relocatable pointer to the address of the
literal is assembled in the location where the literal parameter
appeared.
0200

0376 01

0376

002;,

<20

This feature is ·intended primarily for use in passing external
subroutine arguments with the ARG pseudo-operator, which is
·explained in greater detail later in the chapter.

Parameters
A parameter is generally either a numeric constant, a literal or
a user-defined address symbol, which is intended to represent data
rather than serve as an instruction. It appears as an operand in a
statement line containing no operator. (An exception to this is a
parameter used in conjunction with the ARG pseudo-operator, explained in Subroutines.) In the following example, 200 and -320,
M, and PGOADR all represent parameters.

0200
0201
0202
02:03

0200
7460
0315
0176

ABC,

2 (i) CJ ; - 3 2 () ; "fvj

POINTR, PGOArR

Symbols
Symbols are composed of legal alphanumeric characters and are
delimited by a non-alphanumeric character. There are two major
types of symbols: permanent, and user-defined.
Permanent Symbols
Permanent symbols are predefined and maintained in SABR's
permanent symbol table. They include all of the basic instructions
and pseudo-operators in Appendix C. These symbols may be used
without prior definition by the user.
2-7

User~Defined Symbols

A user-defined symbol is a string of from one to six legal alphanumeric characters delimited by a non-alphanumeric character.
User-defined symbols must conform to the following rules:

1. The characters must be legal alphanumericsABCD ... XYZ, [] ""'t and 0123456789.
2. The first character must be alphabetic.
3. Only the first six characters are meaningful. A symbol
such as INTEGER would be interpreted as INTEGE.
Since the symbols GEORGE 1 and GEORGE2 differ only
in the seventh character, they would be treated as the
same symbol: GEORGE.
4. A user-defined symbol cannot be the same as any of the
pre-defined permanent symbols.
5. A user..,defined symbol must be defined only once. Subsequent definitions will be ineffec.tive and will cause SABR
to type the error message M (Multiple Definition).
A symbol is defined when it appears as a symbolic address label
or when it appears in an ABSYM, COMMN, OPDEF or SKPDF
statement (see Pseudo-Operators). No more than 64 different userdefined symbols may occur on any one core page.

Equivalent Symbols
When an address label appears alone on a line-with no instruction or parameter-the label is assigned the value of the next address assembled.
TAGl,
TAG2,
TAG3,

TAG 1 and T AG2 are equivalent symbols in that they are assigned the same value. Therefore, a TAD TAG 1 will reference the
data at T AG2. T AG3, however, is not equivalent to T AG2. T AG3
would be defined as 1 greater than T AG2.
COMMENTS
A programmer may add notes to a statement by preceding them
with a slash mark. Such comments do not affect assembly or program execution but are useful in interpreting the program listing

2-8

for later analysis and debugging. Entire lines of comments may be
present in the program.
None of the special characters or symbols have significance
when they appear in a comment.
/THIS rs A COMMENT LINE·
/THIS ALSO. TAD;CALL;#"-2C+:::!
A,
TAD SAVE
/SLASH STARTS COMMENT

Incrementing Operands

Because SABR is a one-pass assembler and also because it
sometimes generates more than one machine instruction for a
single user instruction, operand arithmetic is impossible. Statements of the form:
TAD TAG+3
TAD LIST-LIST2
JMP • +6

are illegal. However, by appending a number sign to an operand
the user can reference a location exactly one greater than the
location of the operand (the next sequential location) : TAD
LOC# is equivalent to the PAL language statement TAD LOC+ 1.
0200
020 1
0202
0203

0020
00 30
1200
1201

LOC,

0400
0 40 1

0200
0201

A,
B,

START,

20
30
TAD LOC
TAD LOC#
PAGE
LDC
LOC#

/GET 20
/GET 30

In assembling #-type references SABR does not attempt to determine if multiple machine code words are generated at the symbolic address referenced.
START,

TAD I
NOP

LOC

/LOC IS OFF-PAGE
/USER HOPES TO MODIFY

TAD
DCA

C7500
START#

/SMA

2-9

In the preceding example the user wishes, to change the NOP instruction to an SMA. However, this is not possible because TAD
I LOC will be assembled as three machine code words; if START
is at 0290, the NOP will be at 0203. The SMA will be inserted at
0201, thus destroying the second word of the TAD I LOC execution.
To avoid this error, the user should carefully examine the assembly listing before attempting to modify a program with #-type
references. In the previous example the proper sequence is:
0202
0203
0204
0205
0206
0207
0 377

4067
0200 01
1407
7000
1377
3205
7500

START,

TAD I LOC

VAR,

NOP

TAD (7500
DCA VAR

The #-sign feature is intended primarily for manipulating
DUMMY variables when picking up arguments from external subroutines and returning from external subroutines (see Passing Subroutine Arguments).
Pseudo-Operators
Table 2-1 lists all the Pseudo-operators available . in SABR,
whether used as a free-standing assembler, or in conjunction with
the Fortran compiler. The pseudo-operat~rs are categorized and
explained in the following paragraphs.

Table 2-1

SABR Pseudo-Operators

Mnemonic
ABYSM
ARG
BLOCK
CALL
COMMN
CPAGE
DEC IM
DUMMY
EAP

Operation
Direct Absolute Symbol Definition
Argument for Subroutine Call
Reserve Storage Block
Call External Subroutine
Common Storage Definition
Check if Page Will Hold Data
. Decimal Conversion
Dummy Argument Definition
Enter Automatic Paging Mode
2~10

Table 2-1 (Cont.) SABR Pseudo-Operators

Mnemonic
END
ENTRY
FOR TR
IF
LAP
OCTAL
OPDEF
PAGE
PAUSE
REORG
RETRN
SKPDF
TEXT
ACH
ACM
·ACL

Operation
End of Program
Define Program Entry Point
Assemble FORTRAN Tape
Conditional Ass~mbly
Leave Automatic Paging
Octal Conversion
Define Non-Skip Operator
Terminate the Page
Pause for Next Tape
Terminate Page and Reset Origin
Return from External Subroutine
Define Skip-Type Operator
Text String
Floating-Point Accumulator
20*
high-order word
21 *
middle word
22 *
low-order word

* The floating point accumulator is in field 1.
ASSEMBLY CONTROL
END
Every program or subprogram to be assembled
must contain the END pseudo'.'"op as its last line.
If this requirement is not met, an error message
(E) is given.
PAUSE
The PAUSE pseudo-op causes assembly to halt
and is designed to allow the program.mer to break
up a large source tape into several smaller segments. To do this, the programmer need only
place a PAUSE statement at the end of each section of his source program except the last. Each
of these sections of the program is then output as
an individual tape. When assembly halts at a
PAUSE, the user removes the source tape just
read from the reader and inserts the next one.
Assembly may then be continued by pressing the
CONTinue switch.
2-11

WARNING

The PAUSE pseudo-op is designed specifically for use at the end of partial tapes and
should not be used otherwise.

DECIM

OCTAL

The reason for this is that the reader routine may
have read data from the paper tape into its buffer
that is actually beyond the PAUSE statement.
Conseque·ntly, when CONTinue is pressed after
· the PAUSE is found by the line interpreting routine, the entire content of the reader buffer following the PAUSE is destroyed, and the next tape
begins reading into a fresh buffer. Thus, if there
is any meaningful data on the tape beyond the
PAUSE statement, it will be lost.
Initially the numeric conversion mode is set for
.octal conversion. However, if the user wishes, he
may change it to decimal by use of the DECIM
pseudo-op.
If the numeric conversion mode has been set to
decimal, it may be changed back to octal by use
of the OCT AL pseudo-op.
No matter which conversion mode has been permanently set, it may always be changed locally
for literals by use of the (Dor (K syntax described
earlier. For example:
START,

0~00

(1320

0 201
0202
020 3

0 500
0 377 0 1
1000

(i'J 20 Lj

0 512
0 376 01
0320

32t5'
DEC IM
320
CK320
512

OCTAL
020 5
0206

512
CD512
320

EtJD
0376
0377

1000
0320

2-12

LAP

EAP

PAGE

REORG

CPAGE

The assembler is initially set for automatic generation of jumps to the next core page when the page
being assembled fills up (Page Escapes), or when
PAGE or REORG pseudo-ops are encountered.
This feature may be suppressed by use of the
LAP (Leave Automatic Paging) pseudo-op.
If the user has previously suppressed the automatic paging feature, it may be restored to operation by use ~f the EAP (Enter Automatic
Paging)·· pseudo-op.
The PAGE pseudo-op causes the current core
page to be assembled as is. Assembly of succeeding instructions will begin on the next core page.
No argument is required.
The REORG pseudo-op is similar to the PAGE
pseudo-op, except that a numerical argument
specifying the relative location within the subprogram where assembly of succeeding instructions is to begin must be given. A REORG below
200 may not be given. A REORG should always
be to the first address of a core page. If a REORG
address is not the first address of a page, it will
be converted to the first address of the page it
is on.
0200

7200

0400

7040

1000

7041

START,

CLA
PAGE
CMA
REORG 1(2J00
CIA

The CP AGE pseudo-op followed by a numerical
argument N specifies that the following N words of
code 1 must be kept together in a single unit and
not be split up by page escape.s and literal tables.
If the N words of code will not fit on the current
page of code, the current page is assembled as if a

Normally data. However, if these N words are instructions, for example
a CALL with arguments, it is the user's responsibility to count extra
machine instructions which must be inserted by SABR.

2-13

PAGE pseudo-op had been encountered. The N
words of code will then be assembled as a unit on
the next core page. An example follows.

NOTE
N must be less than or equal to 200 (octal)
in nonautomatic paging mode or less than or
equal to 17 6 octal in automatic paging mode.

02r!r!

7?.'.1.1

STC\RT,

CL.A
LAP
CPAGE 21:1

0400

0':1'.J:1

NA~F.l

(?)4(11

(?)'.1(1/l

~A~F.2

/INEI~IT PAGE ESCAPE
ICL0SES THE
/CURRENT PAGE
/AND ASSF.MPLES
/TEE :JEXT PAGE

The conditional pseudo-op, IF, 1s used with the
following syntax:
IF NAME, 7

The action of the pseudo-op in this case is to first
determine whether .the symbol NAME has been
previously defined. If NAME is defined, the
pseudo-op has no effect. If NAME is not defined,
the next seven symbolic instructions (not counting
null lines and comment lines) will be treated as
comments and not assembled.

/ARSYM NAME 176
IF NAME, 2
/THE ~EXT LINE
CLL RTL
/Tr PE ASSEMBLED
RAL
/\•:I LL PE "DCA LOC"
I IF THE SLASH PEFORE "i\:'SYi\'. NAt>~E 1 76"
/IS REMOVED, THE "CLL RTL" AND "RAL"
/WILL PE ASSEMRLED.
0200
0201

320 1
0000

DCA LOC
LOC,

2-14

Normally the symbol referenced by an IF statement should be e'ither an undefined symbol or a
symbol defined by an ABSYM statement. If this
is done, the situation mentioned below cannot
occur.
WARNING
In a situation such as the following, a special
restriction applies.

NAME,

IF NAME, 3

The restriction is that if the line NAME, 0 happens to occur on the same core page of instructions as the IF statement, then, even though it is
before the IF statement, NAME will not have been
previously defined when the IF statement is encountered, and on the first pass (though not in the
listing pass) the three lines after the IF ~tatement
will not be assembled. The reason for this is that
location tags cannot be defined until the page on
which they occur is assembled as a unit.
SYMBOL DEFINITION
ABSYM
An absolute core address may be named using the
ABSYM pseudo-op. This address must be in the
same core field as the subprogram in which it is
defined. The most common use of this pseudo-op
is to name page zero addresses not used by the
operating system. These addresses are listed under
Linkage Routine Locations.
OPDEF
Operation codes not already included in the symSKPDF
bol table may be defined by use of the OPDEF or
SKPDF pseudo-ops. Non-skip instructions must
be defined with the OPDEF pseudo-op and skiptype instructions must be defined with the SKPDF
pseudo-op.
2-15

Examples of ABSYM, OPDEF and SKPDF syntax:

0177
0010
6761
6771
7540

ABSYM
ABSYM
OPDEF
SKPDF
SKPDF

TEM
AX
DTRA
DTSF
SMZ

177

/PAGE 0 ADDRESSES

10
6761
6771
7540

/NON-SKIP INSTR.
/SKIP-TYPE INSTR·

NOTE
ABSYM, OPDEF and SKPDF definitions
must· be made before they are used in the
program.

COMMN

The COMMN pseudo-op is used to name locations in field 1 as externals so that they may be
referenced by any program. If any COMMN statements are used, they must occur -at the beginning
of the source, before everything else including
the ENTRY statement. Common storage is always
in field 1 and is allocated from location 0200
upwards. Since the top page of field 1 is reserved,
no more than 3840 111 words of common storage
'-may be defined.
A COMMN statement normally takes a symbolic
address label, since storage is being allocated.
However, common storage may be allocated without an address label.
A COMMN statement always takes a numerical
argument which specifics how many words of
common storage arc to be allocated~ however. a
0 argument is allowed. A COMMN statement
with 0 argument allocates no common storage~
it merely defines the given location symbol at the
next free common location.
The syntax of the COMMN statement is shown
as follows.
'--

2-16

0200
0220
0230
0 530
0 530

A,
B,

CCJ:\MN 20
COIV:MN 10
COM!v'!N 300
CCiv:MN 0
COMMN 10
ENTRY SUERUT

c,
D,

In this example 20 words of common storage are
allocated from 0200 to 021 7, and A is · defined
at location 0200. Then, 10 words are allocated
from 0220 to 0227, and B is defined at 0220.
Notice that if A is actually a 30 word array, this
example equates B(l) with A(21).
The example continues by allocating common
storage from 0230 to 0527 with no name being
assigned to this block. Then 10 words are allocated from 0530 to 053 7 with both C and D
being defined at 0530.
DATA GENERATING
BLOCK
The BLOCK pseudo-op given with a numerical
argument N will reserve N words of core by
placing zeros in them. This pseudo-op creates
binary output, and thus may have a symbolic
address label.
Before the N locations are reserved, a check is
made to see if enough space is available for them
on the current core page. If not, this page is assembled and the N locations are reserved on the
next core page. The action here is similar to that
of the CPAGE pseudo-op. Similar restrictions on
the argument apply.
/EXAMPLE OF HOW LARGE BLOCK STORAGE
/MAY BE ACHIEVED WITHIN A SUBPROGRAM AREA
LAP
RLOCK 200
llLOCK 200
DLOCK 100
EAP

2-17

/INHIBIT PAGE ESCAPES
/RESERVE 500
/COCTAL) LOCATIONS
/RESUME NORMAL CODING

As a special use, if the BLOCK pseudo-op is used
with a location tag (but with no argument or a
zero argument), no code zeros are assembled; instead the symbolic address label is made equivalent to the next relative core location assembled.
(This is equivalent to using a symbolic address
label with no instruction on the same line.)

0200
0201
0202

0203
020LJ

TEXT

()0()0
0000
0000

0000

LIST,

NAME!,
NAME2,
NAMEJ,
NAMELJ,

PLOCK 3

BLOCK
PLOCK 0

/ASSEMSLES .4.S
/THREE ZEROS
/WITH "LIST"
/DEF I I\ ED .4.T TEE
IF IRST LOCATIOJ:\
/DEF INES ~M-'.El=
/NM1E2=NAf·:E3=
/NA.MEL!

BLOCK 2

0000

The TEXT pseudo-op is used to obtain packed
six-bit ASCII text strings. Its function and use
are almost exactly the same as for the BLOCK
pseudo-op except that instead of a numerical argument, the argument is a text string. In particular, a check is made to be sure that the text
string will fit on the current page without being
interrupted by literals, etc.
The text string argument must be contained on
the same line as the TEXT pseudo-op. Any printing character may be used to delineate the text
string. This character must appear at both the beginning and the end of the string. Carriage return,
line feed and form feed are illegal characters
within a text string (or as de line a tors). All characters in the string are stored in simple stripped
six-bit form. Thus, a tab character (ASCII 211 )
will be stored as an 11, which is equivalent to the
coding for the letter I. In general, characters outside the ASCII range of 240-337 should not be
used.
2-18

0200
0201
0202
0203
0204
020 5
0 20 6
0207
0210
0211

TAG,

2405
3024
4005
3001
1520
140 5

TEXT

/TEXT EXAKPLE 123*;?/

LJ~161

6263
5273
7700

Subroutines

A subroutine is a subprogram which performs a specific operation and is generally designed so that it can be used more than
once or by more than one program. Direction of flow goes from the
m~in, or calling, program to the subroutine, where the action is
performed, followed by a return back to the address following the
subroutine call in the main program.
Internal subroutines are those subroutines which can only be .
called from within a program. This type of subroutine is used
extensively in nearly all PDP-8 programs, and is handled through
the use of the JMS, JMS I, and JMP I instructions. An example of
an internal subroutine call follows:
0200
0201
0202

7300
1204
4206

START,

/GET NUMBER IN AC
/TRANSFER TO SUB/ROUTINE
DCA RESLT /STORE NUMBER
/CCONTROL RETURNS
/HERE)

0203 ' 320 5
0204
0205

0001
0000

0206
0207

0000
7104

0210
0 211
0 212
0213

7430.
7402
6201 05
5606

CLA CLL
TAD N
JMS TWO

RESLT,

/SUBROUTINE
TWO,
0
CLL RAL

/ROTATE LEFT AND
/MULTIPLY BY 2
/CHECK FOR OVERFLOW
SZL
HLT
/STOP IF OVERFLOW·
JMP I TWO /RETURN TO MAIN
/PROGRAM
END

The main program picks up a number (N) and jumps to the
subroutine (TWO) where N is multiplied by two. A check is made,
2-19

and if there is no overflow, control retUf!lS to the main program
through the address stored at the location TWO.
External subroutines are distinguished from internal subroutines by the fact that they may be called by a program which has
been compiled, or assembled, without any knowledge of where the
subroutine will be located in core memory. Thus, external subroutines must be loaded with a relocatable linking loader. This
makes it possible for a programmer to build a library of frequently
used programs and subroutines which can be combined in various
configurations, and eliminates the need to reassemble, or recompile,
each individual program when a minor change is made in the
system.
A call to an external subroutine can be illustrated using the
following FORTRAN programs:

100

IPARM=S
CALL TWO< !PARM)
WRITE <1,100) !PARM
FORMAT <IS)
END

(Calling Program)

SUBROUTINE TWO<IARG)
IARG=IARG+IARG
RETURN
END

(Subroutine)

NOTE
Care should be exercised when naming a
function or subroutine. It must not have the
same name as any of the assembler mnemonics or pseudo-ops or FORTRAN/SABR
library functions or subroutines, as errors are
likely to result. The symbol table for SABR
Assembler is listed in Appendix C, and the
library functions are described in the section
The Subprogram Library.
Any time a subroutine is called, it must have data to process.
This data is contained in parameters in the calling program which
are then passed to the subroutine. The data is picked up by the
subroutine where it is referred to as arguments. (The subroutine
actually picks up the arguments by a series of TAD l's, and one

2-20

final TAD I for an integer argument, or by a call to the IFAD
subroutine if a floating point argument. This is illustrated in the
section entitled SABR Programming Notes.) SABR has special
pseudo-operators which facilitate the passing/handling of arguments, and each will be explained in turn.
~

CALL AND ARG
The CALL pseudo-op is used by the main program to transfer
control to the subroutine and is of the form:
CALL n,NAME
where n represents a one or two-digit number ( 62 10 maximum)
indicating the· number of parameters to be passed to the subroutine, and NAME (separated from n by a comma) represents the
symbolic name of the subroutine entry point.
The Assembler must know the number of parameters which
follow the call so that enough room on the current page can be
allowed. The CALL pseudo-op and its corresponding parameters
must always be coded on the same memory page; that is, there
must be no intervening page escapes. (Page format and page escapes are discussed later in the chapter.)
The ARG pseudo-op is used only in conjunction with CALL
and consists of the symbol ARG followed by one of the ·parameters (referred to as arguments in the subroutine) to be passed.
One ARG statement must be coded for each parameter.
In the previous FORTRAN example, the main program (or it
may have been a subroutine) called a subroutine named TWO, and
supplied one argument:

CALL 1,rwo
ARG !PARM

SABR actually assembles the above instructions as follows (the
user may wish to consult the section concerning the Loader Relocation Codes) :
2-21

0200

0000

0206
0207
0210
0 211

40 33
0103 06
6201 0 5
0 200 01

IPARM,

BLOCK 1

CALL 1,TWO
ARG

!PARM

END

ENTRY AND RETRN
In the subroutine, the ENTRY statement must occur before the
name of the entry point appears as a symbolic address label. The
actual entry location must be a two"."word reserved space so that
both-the return address and field can be saved when the routine
is called. Execution of the subroutine begins at the first location
following the two-word ENTRY block. For example, the TWO
subroutine mentioned in the previous example would begin as follows:
0 200
0201

0000
0000

0227
0230

4040
0001 06

TWO,

ENTRY TW 0
BLOCK 2

RETRN

TWC

END

When a subroutine is referenced in a CALL statement, the
Run-Time Linkage Routine LINK executes the transfer to the subroutine. It assumes that the entry point to the routine is a twoword block. Into the first word of this block it places a CDF instruction which specifies the field of the calling program. In the
second word it places the address from which the CALL occurred.
(This is analogous to the operation of the JMS instruction.) In
the previous example, if the MAIN program had been in field 0,
a 6201 would have been deposited in the location at TWO, and a
0210 at TWO#.
The RETRN statement allows the user to return to the calling
program from the subroutine. The name of the subroutine being
returned from must be specified in the RETRN statement so that
the Return Linkage Routine can determine the action required,

2-22

and also because a subroutine may have differently named ENTRY
points. (This is analagous to the operation of a JMP I instruction.)
When a subroutine is entered, the second word of the entry name
block contains the address of the argument or next instruction
immediately following the subroutine call in the. calling program,
and it is to this address that control returns.
EXAMPLE
A user wishes to write a long main program, MAIN:!, which
uses two major subroutines, S 1 and S2. S 1 requires two arguments
and S2 one argument. The user writes MAIN, Sl, and S2 as three
separate programs in the following manner:
MAIN,

ENTRY MAIN
CLA

/START OF MAIN

CALL 2,Sl
ARG X
ARG Y
CALL 1,s2
ARG Z
ENP

Sl,

ENTRY Sl
BLOCK 2
RETRN Sl
END

s2,

ENTRY S2
BLOCK 2

RETRN 52
END
2

A useful procedure in SABR programming is to provide an ENTRY
point named MAIN in the main program at the address where execution
is to begin. This assures that the starting address of the program will
appear in the Linking Loader's symbol print-out where it may be easily
referenced. If using OS/ 8, execution will begin at this address automatically, eliminating the need to specify a 5-digit starting address.

2-23

S 1 could also contain calls to S2, or S2 c~lls to SI. Each of these
programs is independently assembled with SABR and loaded with
the Linking Loader. During the loading process, all of the proper
addresses will be saved in tables so that when the user begins
execution of MAIN, the Run-Time Linkage Routines (see SABR.
Operating Characteristics), which were autornatica11y loaded, will
be able to execute the proper reference. Thus, MAIN will be able
to fully use Sl and S2 and be able to pass data to and receive it
from them.
Passing Subroutine Arguments
DUMMY
A DUMMY pseudo-op is used in SABR to define a two word
block which contains an argument address. Indirect instructions
are used to pass arguments to and from subroutines through these
DUMMY variables. If a DUMMY variable is referenced indirectly,
it causes a CALL to the DUMMY Variable Run-Time Linkage
Routine (see Run-Time Linkage Routines) which assumes that
the DUMMY variable is a two-word reserved space where the
first word is a 62N 1 ( CDF N), with N representing the field of
the address to be referenced, and that the second word contains a
12-bit address.
As an example, consider the FORTRAN subroutine TWO
shown earlier. This could be written in SABR as follows (the user
may wish to refer to the section concerning the Subprogram
Library):

2-24

/CALLED BY:

CALL

ENTRY TWO

0 200
0 201
0 202
0203
0204
020 5
0206
0207
0 210
0 211
0212
0213
0214
0215
0216
0 21 7
0 220

0000
0000
0000
0000
4067
0202 01
140 7
2203
3200
4067
0202 01
140 7
2203
3201
406.7
0200 0 1
1407

0221
0222
0223
.0224
0225
0226

4067
0200 01
140 7
4067
0200 01
3407

0227
0230

4040
0001 06

IARG,

DUMMY IARG
BLOCK 2

TWO,

BLOCK 2

Two

CIARG)
/DEFINE THE
/ENTRY PT· USED
IT 0 P I Cf\ UP AR G •
/ENTRY POINT

TAD I TWO
INC TWO#
DCA IARG
TAD I TWO

/GET ARG ADDRESS

INC TWO#
DCA IARG#
,TAD I IARG

/GET ARGUMENT

TAD I

IARG

I INTO AC
/ADD IT AGAIN

DCA I

IARG

/RETURN ARG· TO
/CALLING PROGRAM

RETRN TWO
END

A second example may be one in which a user has written a
FORTRAN program which contains a call to a SABR subroutine
ADD:
A=2
N=3

CALL ADDCA,N,C)
WRITE Cl,20)C
FORMAT C' THE SUM IS',F6.l)
STOP
END

2-25

The FORTRAN program is compiled and the resulting SABR
code translates the subroutine call as follows:
0223
0224
0225
0226
0227
0230
0231
0232

4033
030 5
6201
0200
6201
0203
6201
0204

CALL 3,ADD
06
05
01
05

ARG A
ARG N

05
01

ARG C

The CALL statement defines 3 parameters-A, N, and C, and the
subroutine name ADD. The subroutine itself would appear as
follows (the DUMMY variables X, K, and Z facilitate the passing
of the arguments to and from the subroutine):

2-26

0200
0201
0·202
0203
0204
0205
0206
0 207
0·210
0 211
0212
0213
0214
0215
0216
0217
0220
0221
0222
0223
0224
0225
"0226
0227
0230
fJ231
0232
0233
0234

0000
0000
0000
0000
0000
0000
0 200 0 1
0000
0000
0000
0000
1206
3207
1377
3210
4067
0211 01
1407
2212
6201 05
3607
2207
2210.
5217
4067
.0202 01
1407
4033
0002 06

0235
0236
0237
0240
0241
0242
0243
0244
0245
0246
0377

4033
0103 06
6201 05
0200 01
4033
0104 06
6201 05
0204 01
4040
0001 06
7772

/CALLED BY: CALL ADD cx,K,Z)
ENTRY ADD
DUMMY x
DUMMY K
DUMMY z
x,
BLOCK 2
K,

BLOCK 2 \.

BLOCK 2

XPNT,
PNTR,
CNTR,
ADD,

0
0
.BLOCK 2

Al,

TAD XPNT
DCA PNTR
TAD C-6
DCA CNTR
TAD I ADD

x
/ENTRY POINT

INC ADDI
DCA I PNTR
INC PNTR
ISZ CNTR
JMP Al
TAD I K

/GET 2ND ARG

CALL 0,FLOT

/CONVERT TO

CALL l,IFAD

/FLOATING PT.
/ADD lST ARG

ARG X
CALL 1,ISTO
ARG Z
RETRN ADD
END

2--27

/RETURN RESULT

The COMMN pseudo.-op may be used to specify variables as
externals so that they may be referenced by any program. This
pseudo-op has been explained under Symbol Definition; an example of its usage is included here.

0200
0 20 1
0202
020 3
0 204
020 5
020 6
0207
0210
0 21 1
0212
0213
0214
0215
0216
0 21 7

0200

COMMN 3

0000
0000
40 33
0102
6211
0200
4033
010 3
6211
0200
4033
0104
6211
0200
4040
0001

CSQR,

ENTRY CSQR
BLOCK 2

/RESERVES COMMON
/STORAGE
/DSFINES ENTRY PT.
/ACTUAL ENTRY POINT

CALL 1, FAD

/GET THE ARGUMENT

06
ARG

CALL 1, FMP

/M'()LT !PLY IT

06
ARG C
CALL 1, STO
06
ARG

/REPLACE WITH RESULT

RETRN CSQR

/RETURN TO CALLING

06
/PROGRAM
END

This subroutine computes the square of a variable C. C resides
in field 1 in common storage where it can be referenced by any
calling program through argument passing. The above is equivalent ·
to the FORTRAN subroutine:
SUBROUTINE CSQR
COMMON C
C=C*C
RETURN
END

SABR Operating Characteristics
PAGE-BY-PAGE ASSEMBLY
SABR assembles page-by-page rather than one instruction at a
time. To accomplish this it builds various tables as instructions
are read. When a full page of instructions has been collected
(counting literals, off . . page pointers and multiple word instructions) the page is assembled and punched. Several pseudo-operators are available to control page assembly.

2-28

Page Format
A normal assembled page of code is formatted as below:

xooo
ASSEMBLED
INSTRUCTIONS

JUMP TO
PAGE ESCAPE
LITERALS
AND
OFF-PAGE
POINTERS

X377

PAGE
ESCAPE

Literals and off-page pointers are intermingled in the table at
the end of the page.
Page Escapes
SABR is normally in automatic paging mode: it connects each
assembled core page to the next by an appropriate jump. This is
called a page escape. For the last page of code, SABR leaves the
Automatic Paging Mode and issues no page escape. The LAP
(Leave Automatic Paging) pseudo-operator turns off the automatic paging mode. EAP (Enter Automatic Paging) turns it back.
on if it has been turned off.
Two types of page escape may oe generated depending on
whether or not the last instruction is a skip. If the last instruction
is not a skip, the page escape is as follows:

last instruction (non-skip)
5377 (JMP to xl 77)
literals
and
off-page
pointers
xl 77 /NOP

If the last instruction on the page is a skip type, the page escape
takes four words, as follows:
last instruction (a skip J
5376 (JMP to xl 76)
5377 (JMP to x177)
literals
etc.
x176/SKP
x177/SKP
MULTIPLE WORD INSTRUCTIONS·
Certain instructions in the source program require SABR to
assemble more than one machine language instruction (e.g., offp_age indirect references and indirect references where a data field
re-setting may be required). In the listing, the source instruction
will appear beside the first of the assembled binary words.
A difficulty arises when a multiple word instruction follows a
skip instruction. The user need be aware that extra instructions
are automatically assembled to enable the skip to be effected correctly.
RUN-TIME LINKAGE ROUTINES
These routines are loaded by the Linking Loader and perform
their tasks automatically when certain pseudo-ops or coding sequences are encountered in the user program. The user needs
knowledge of them only to better understand the program listing.
(The user may wish to refer to the section entitled Loader Relocation Codes.)
There are seven linkage routines:

1. Change data field to current and skip
2. Change data field to 1 (common) and skip
3. Off-page indirect reference linkage
4. Off-bank (common) indirect reference
linkage
5. Dummy variable indirect reference linkage
6. Subroutine call linkage
7. Subroutine return linkage
2-30

CDFSKP
CD ZS KP
OPISUB
OBISUB_
DUMSUB
LINK
RTN

The .individual linkage routines function as follows:
1. CDFSKP is called when a direct off-page memory reference follows a skip-type instruction requiring the data field to be
reset to the current field.
Program

SZA
DCA LOC

Assembled
Code

·Meaning

7440
4045
7410
3776

call CDFSKP
SKP in case AC= 0 at .-2
execute the DCA via a ·
pointer near the end of the
page.

2. CDZSKP is called when a direct memory reference is made
to a location in common (which is always in Field 1). The action of CDZSKP is the same as that of CDFSKP except that it
always executes a CDF 10 instead of a CDF current (see Loader
Relocation Codes) .
Program

SZA
DCA CLOC

Assembled
Code

_Meaning

7440
4051
7410
3776

call CDZSKP
SKP in case AC= 0 at .-2
execute the DCA via a
pointer near the· end of the
page.

3. OPISUB is called when there is an indirect reference-to an
off-page location.
Program

DCA I PTR

Assembled
Code

Meaning

4062
0300 01
3407

call OPISUB
relative address of PTR
execute the DCA I via 0007

4. OBISUB is called when there is an indirect reference to a
location in common storage. In such a case it is assumed that the
2-31

location in common which is being indirectly referenced points to
some location that is also in common.
- Program
DCAI CPTR

Assembled
Code

Meaning

4055
1000
3407

call OBISUB
address of CPTR in Field 1 .
execute the DCA I via 0007

5. DUMSUB is called when there is an indirect reference to
a DUMMY variable. In such a case, DUMSUB assumes that the
DUMMY variable is a two-word vector in which the first word is
a 62N 1, where N ::::: the field of the address to be referenced, and
the second word is the actual address to be referenced.
Program
DCAIDMVR

Assembled
Code

Meaning

4067
0300 01
3407

call DUMSUB
relative address of DMVR
execute DCA I via pointer
in location 0007

6. LINK is called to execute the linkage required by a CALL
statement in the user's program. When a CALL statement is used,
it is assumed that the entry point of the subprogram is named in
the CALL and that this entry point is a two-bit word, free block followed by the executable code of the subprogram. LINK leaves the
return address for the CALL in these two words in the same format
as a DUMMY variable.
Program
CALL2, SUBR
ARGX
ARGC

Assembled
Code

Meaning

-4033

call LINK
code word
X resides in field M
relative address of X
C is in common
absolute address of C

0205 06
62Ml
0300 01
6211
1007

7. RTN is called to execute the linkage by a RETRN statement in the user's program.
2-32

Assembled
Code

Program
RETRN SUBR

Meaning

4040
0005 06

call RTN
number of the subprogram
being returned from ( SUBR)

SKIP INSTRUCTIONS
In page escapes and multiple word instructions, skip-type instructions must be distinguished from. non-skipping instructions.
For this reason both ISZ and INC are included in the permanent
symbol table. ISZ is considered to be a skip instruction and INC
is not. INC should be used to conserve space· when the programmer desires to increment a memory word without the possibility
of a skip.
The first example below shows the code which is assembled for
an indirect reference to an off-page location follo~ing an INC instruction. The second example shows the same code following an
ISZ instruction.
EXAMPLE 1:
INC POINTR
TAD I LOC2

0220
0221
0222
0?23

2376
4002
0520 01
1LJ07

/OFF PAGE

INrIR~CT

EXECUTION

EXAMPLE 2:
I SZ. COUNTR
TAD I LOC2

0220
221
0222
0223
0224
(IJ?,?,5

(ij

2376
7410
5226
4062
0 520 0 1
140 7

/SKIP TO EXECUTION
/JUMP OVER EXECUTION

!OFF PAC.1E INDIRECT EXECUTION

A special pseudo-operafor, SKPDF, must be used to define skip
instructions used in source programs but not included in the permanent symbol table. For example:
SKPDF DTSF 6771

2-33

PROGRAM ADDRESSES
Since each assembly is relocatable, the addres'Ses specified by
SABR always begin at 0200, and all other addresses are relative
to this address. At loading time, the Linking Loader will properly
adjust all addresses. For example, if 0200 and 1000 are the relative
addresses of A and B, respectively, and if A is loaded at 2000,
then B will be loaded at 2000 + ( 1000-0200) or 2600.
All programs to be assembled by SABR must be arranged to fit
into one field of memory, not counting page 0 of the field, or the
top page (7600 - 7777). If a program is too large to fit into one
field, it should be. split into several subprograms.
Explicit CDF or CIF instructions are not needed by SABR programs because of the availability of external subroutine calling and
common storage. Explicit CDF or CIF instructions cannot be assembled properly.
THE SYMBOL TABLE
Entries in the symbol table are variable in length. A one or twocharacter symbol requires three symbol table words. A three- or
four-character symbol requires four words, and a five- or sixcharacter symbol, five words. Thus, for long programs it may be
to the user's advantage to use short symbols whenever possible.
The symbol table, not counting permanent symbols, contains
264410 words of storage. However, this space must be shared
when there are unresolved forward and external references temporarily stored as two-word entries.
If we may assume that a program being assembled never has
more than 10010 of these unresolved references at any one time,
this leaves 246410 words of storage for symbols. Using an average
of four words per symbol, this allows room for 61610 symbols.
The OS/8 version of SABR has a smaller space for symbol
tables, leaving 1364 10 words of storage, or 162010 if used as the
second pass of 8K FORTRAN.
Symbol table overflow is a fatal condition which generates the
error message ~·
Symbol Table Flags
Symbols are listed in alphabetic order at the end of the assembly
pass 1 with their relative addresses beside them. The following
flags are added· to denote special types of symbols:

2-34

ABS

The address referenced by this symbol is absolute.

COM

The address is in common.

The symbol is an operator.

EXT

The- symbol is an external one and may or may not
be defined within this program. If not defined, there
is no difficulty; it .is defined in another program.

UNDF

The symbol is not an external symbol and has not
been defined in the program.· This is a programmer
error. No earlier diagnostic can be given because it
is not known that the symbol is undefined until the
end of pass 1. A location is reserved for the undefined symbol, but nothing is placed in it.

The Subprogram Library

The Library is a set of subprograms which may be CALLed by
any FORTRAN/SABR program. These subprograms are automatically loaded with the OS/8 FORTRAN/SABR system; in the
paper ·tape system they are provided on two relocatable binary
. paper tapes with part 1 containing those subprograms used by
almost every FORTRAN/SABR program. This allows the user
to load only those routines which his program makes use of, thus
conserving symbol space.
Many of the subprograms reference the Floating-Point Accumulator located at ACH, ACM, ACL ( 20,21,22 of field 1). The
OS/8 Subprogram Library is summarized in the 8K FORTRAN
chapter. The organization of the library programs, as they are provided in the paper tape system, is described in the following pages.
Part 1. "JOH"
"FLOAT".

contains IOH, READ, WRITE
contains FAD, FSB, FMP, FDV, STO,
FLOT, FLOAT, FIX; IFIX,
IFAD, ISTO, CHS, CLEAR
"INTEGER" contains IREM, ABS, IABS, DIV,
MPY, IRDSW
.
contains
"UTILITY''
TTYIN, TTYOUT, HSIN,
HSOUT, OPEN, CKIO
·"ERROR"
contains SETERR,CLRERR,ERROR
2-35

·\

Part. 2. "SUBSC"
"POWERS"
"SQRT"
"TRIG"
"ATAN"

contains SUBSC
contains IIPOW, IFPOW, FIPOW,
FFPOW, EXP, ALOG
contains SQRT
contains SIN, COS, TAN
contains ATAN

INPUT /OUTPUT
READ is called to initialize the I/0 handler before reading data.
WRITE is called to initialize the I/0 handler before writing data.
IOH is called for each item to be read or written; IOH must a]so
be called with a zero argument to terminate an input-output sequence.
All of the programs require that the Floating-Point Accumulator be set to zero before they are called.
CALL

2, READ

ARG

/n=DEVICE NUMBER

ARG

/fa==ADDR OF FORMAT

•••
l, IOH

CALL
ARG

data 1

CALL

1, IOH

ARG

data 2

/data l==ADDR OF HIGH
/ORDER WORD OF
/FLOATING POINT
/NUMBER

••••
•••
1, IOH
0

/TERMINATES READ

/INITIALIZES WRITE

ARG

2, WRITE
(n

ARG

CALL
ARG

•••
CALL

2-36

The following device numbers are currently implemented:
1
2

(Teletype keyboard/printer)
(High-speed reader/punch)
3
3 (Card reader/line printer)
4 3 ( As.signable device)
FLOATING-POINT ARITHMETIC
FAD is called to add the argument to the Floating-Point Accumulator.
CALL
ARG

1, FAD
add res

FSB is called to subtract the argument from the Floating-Point
Accumulator.
CALL
ARG

1, FSB
add res

FMP is called to multiply the Floating-Point Accumulator by
the argument.
CALL
ARG

1, FMP
addres

FDV is called to divide the Floating-Point Accumulator by the
argument.
CALL
ARG

1, FDV
add res

CHS is called to change the sign of the Floating-Point Accumulator.
CALL

0, CHS

All of the above programs leave the result in the Floating-Point
Accumulator. The address of the high-order word of the floatingpoint number is "addres".
STO is called to store the contents of the Floating-Point

3 Device

numbers 3 and 4 are available only under the OS/ 8 Operating

System.

2-37

Accumulator in the argument address. The floating-point accumulator is cleared. '
CALL
ARG

l, STO
storag

/storag=ADDRESS WHERE
/RESULT IS TO BE PUT

IF AD is called to execute an indirect floating-point add to the
Floating-Point Accumulator.
CALL
ARG

1, IFAD
ptr
/ptr=2 WORD POINTER
/TO HIGH ORDER
I ADDRESS OF FLOATING
/POINT ARGUMENT

ISTO is called to execute an indirect floating-point- store.
CALL
ARG

1, ISTO
ptr

CLEAR is called to clear the Floating-Point Accumulator. The
AC is unchanged.
CALL

0, CLEAR

FLOAT and FLOT are called to convert the integer contained
in the AC (processor accumulator) to a floating-point number and
store it in the Floating-Point Accumulator.
CALL

0, FLOT

CALL 1, FLOAT
ARG addr

IFIX and FIX are called to convert the number in the FloatingPoint Accumulator to a 12-bit signed integer and leave the result
in the AC.
CALL

0, FI~

CALL 1, IFIX
ARG addr

ABS leaves the absolute value of the floating-point number at
"addr" in the Floating-Point Accumulator.
CALL
ARG

1, ABS
addr
2-38

INTEGER ARITHMETIC
MPY is called to multiply the integer contained in the AC by
the integer contained in "addr." The result is left in the AC.
CALL
ARO

1, MPY
addr

DIV is called to divide the integer contained in the AC by the
integer contained in "addr." The result is left in the AC.
CALL
ARO

1, DIV
addr

IREM leaves the remainder from the last executed integer divide
in the AC.
CALL
ARO

1, IREM
0

(The argument is ignored.)
IABS leaves the absolute value of the integer contained in
"addr" in the AC.
CALL
ARO

1, IABS
addr

IRDSW reads the value set in the console switch register into
the AC.
CALL

0, IRDSW

SUBSCRIPTING*
SUBSC is called to compute the address of a subscripted variable, and can be used for doubly or singly subscripted arrays. On
entry, the AC should be negative for floating-point variables-any
negative number for singly subscripted variables, and l's complement of the first dimension for doubly subscripted variables. For
doubly subscripted integer variables, the AC must be the first
dimension.
The general calling sequence for SUBSC is as follows:
':'Applies to OS/8 only.

2-39

*TAD <M

/lST DIMENSION <USED ONLY
/IF 2 DIMENSIONS)
/USED ONLY IF ARRAY IS
/FLOAT ING PO INT
2,SUBSC]/SINGLE SUBSCRIPT

*CMA
CALL

[

3,SUBSC
*ARG J
ARG I
ARG BASE
LOCA

/DOUBLE SUBSCRIPT
/2ND DIMENSION
/lST DIMENSION
/BASE ADDRESS OF ARRAY
/ADDRESS OF TWO WORD DUMMY
/ADDRESS, LOCATION

* Optional Statements.
For example, to load the I,Jth element of a floating-point array
whose dimensions are 5 by 7:
TAD <5
CMA
CALL 3,SUBSC
ARG J
ARG I
ARG ARRAY
LOG
CALL 1,IFAD
ARG LOG

/DIMENSIONS ARE 5 BY 7
/ADDRESS OF 2ND SUBSCRIPT
/ADDRESS OF lST SUBSCRIPT
/BASE ADDRESS OF ARRAY
/MUST BE A DUMMY VARIABLE

FUNCTIONS
SQRT leaves the square root of the floating-point number at
"addr" in the Floating-Point Accumulator.
CALL
ARG_

l, SQRT
addr

SIN, COS, TAN leave the specified function of the floating-point
argument at "addr" in the Floating-Point Accumulator.
CALL
ARG

1, SIN
addr

AT AN leaves the arctangent of the floating-point number at
"addr" in the Floating-Point Accumulator.
CALL
ARG

1, ATAN
addr
2-40

ALOG leaves the natural logarithm of the floating-point number at "addr" in the Floating-Point Accumulator.
CALL
ARG

1, ALOG
addr·

EXP raises "e" to the power specified by the floating-:point number at "addr" and leaves the result in the floating-point accumulator.
CALL
ARG

1, EXP
addr

All of these subprograms require that the floating-point accumulator be set to zero before they are called.
The POWER routines (JIPOW, IFPOW, FIPOW, FFPOW)
are called by FORTRAN to implement exponentiation. T~e first
operand is in the AC (floating-point or processor depending on
mode), and the address of the second is an argument. The address
of the result is in the appropriate AC upon return.

MODE OF
OPERAND 1
(BASE)

MODE OF
OPERAND 2
(EXPONENT)

MODE OF
RESULT

II POW
IF POW
FIPOW
FF POW

INTEGE.R
INTEGER
FLOATING POINT
FLOATING POI NT

INTEGER
FLOATING POINT
INTEGER
FLOATING POINT

INTEGER
FLOATING POINT
FLOATING POI NT
FLOATING POINT

CALL
ARG

2, FFPOW
addr 2

FUNCTION
NAME

I ADDRESS OF OPERAND 2

UTILITY ROUTINES
OPEN is called at the beginning of every FORTRAN program
to start the high-speed reader/punch and teleprinter, and to initialize the 1/0 routines for device code 4 if using the OS/8 FORTRAN/SABR system. The form is:

CALL 0, OPEN

2-41

When an error is encountered in a program, the ERROR routine is called. The program passes to the ERROR routine the
address of the error message to be printed. The format of the
error message is 4 characters in stripped ASCII and packed into
2 words:
2343
2344
2345
2346

0102
0304
0000
0000

xyz,

ENTRY ABC
010 2;0 304

ABC,

BLOCK 2

CALL l,ERROR
ARG XYZ

When control passes to the ERROR routine, the parameters
passed are picked up. In the case above, the parameters are as
follows:
62Nl
2343

ARG XYZ

'·

where N is the field that XYZ is in, and 2343 is the address of
XYZ. The ERROR routine then prints the message at location
. 2343 plus a 5-digit address which is 2 greater than 2343.
ARCD ERROR AT N2345

Since XYZ is 2 locations before ABC, the address printed will be
the address of ABC.
The error message is usually placed just before the entry ·point
of the routine in which the error was detected-thus the address
printed by ERROR will be the address of the entry point. This
provides a convenience to the programmer since the entry point
will appear in the Loader Map.
CKIO is a subroutine which waits for the TTY flag to~ be set. It
is called by the OS/8 EXIT subroutine to eliminate the possibility
of a garbled TTY output. It m~y be used in FORTRAN for possible expansion with interrupts, and is of the form:
2-42

CALL 0,CKIO

The following subroutines-IOPEN, OOPEN, OCLOSE,
CHAIN, EXIT, and GENIO-are used by the OS/8 FORTRAN/
SABR Operating System for device independent 1/0 and chaining.
They are discussed in detail in Chapter 1 of this manual.
DECAPE I/O ROUTINES
RTAPE and WTAPE (read and write tape) are the DECtape
read and write subprograms for the 8K FOR TRAN and 8K SABR
systems. The subprograms are furnished on one relocatable binarycoded paper tape which must be loaded into field 0 by the 8K
Linking Loader, where they occupy one page of core.
RTAPE and WTAPE allow the user to read and write any
amount of core-image data onto DECtape in absolute, non-filestructured data blocks. Many such data blocks may be stored on a
single tape, and a block may be from, 1 to 4096 words in length.
RTAPE and WTAPE are subprograms which may be called
with standard, explicit CALL statements in any 8K FORTRAN or
SABR program. Each subprogram requires four arguments separated by commas. The arguments are the same for both subpro ...
grams and are formatted in the same manner. They specify the
following:
1. DECtape unit number (from 0 to 7)
2. Number of the DECtape block at which transfer 'is to
start. The user may direct the DECtape service routine to
begin searching for the specified block in the forward direction rather than the usual backward direction by making
this argument the two's complement of the block number.
3. Number of words to be transferred (1 ~N~4096)
4. Core address at which the transfer is to start.
DECtape 1/0 Routines for the 8K FORTRAN system are explained in Chapter 1. In 8K SABR, the CALL statements to
RT APE and WT APE are written in the following format ( arguments may be either octal or decimal numbers) :

2-43

CALL 4,WTAPE
ARG . C6
ARG C200
ARG

C604

ARG LOCB

/WOULD BE SAME FOR RTAPE
/DATA UNIT NUMBER
/STARTING BLOCK NUMBER
/IN OCTAL
/WORDS TO BE TRANSFERRED
/IN OCTAL
/CORE ADDRESS, START OF
/TRANSFER

In these examples, LOCA and LOCB may or may not be in common.
As a typical example of the use of RT APE and WT APE, assume that the user wants to store the four arrays A, B, C, and D
on a tape with word lengths of 2000, 400, 400, and 20 respectively.
Since PDP-8 DECtape is formatted with 14 74 blocks (numbered
0-2701 octal) of 129 words each (for a total of 190,146 words),
A, B, C, and D will require 16, 4, 4, and 1 blocks respectively.
(The block numbers used by RT APE and WT APE should not be
confused with the record numbers used by OS/8. A OS/8 record
is 256 words-roughly twice the size of a DECtape block.)
Each array must be stored beginning at the start of some DECtape block. The user may write these arrays on tape as follows:
CALL WTAPE
CALL WTAPE
CALL WTAPE
CALL WTAPE

C0,1,2000,A)
C0,17,400,B)
C0,21,400,C)
(0,25,20,D)

The user may also read or write a iarge array in sections by
specifying only one DECtape block ( 129 words) at a time. For
example, B could be read back into core as follows:·
CALL RTAPE C0,17,258,BC1))
CALL RTAPE C0,19,129,BC259))
CALL RTAPE C0,20,13,BC388))

As shown above, it is possible to read or write less than 129
words by starting at the· beginning of a DECtape block. It is impossible, however, to read or write starting in the middle of a
block. For example, the last 10 words of a DECtape block may
not be read without reading the first 119 words as well.
A DECtape read or write is normally initiated with a backward

2-44

search for the desired block number. To save searching time, th_e
user may request RT APE or WT APE to start the block number
search in the forward direction. This is done by specifying the
negative of the block number. This should be used only if the
number of the next block to be referenced is at least ten block
numbers greater than the last block number used. For example,
if the user has just read array A and now wants array D, he may
write:
CALL RTAPE <0,1,2000,A)
CALL RTAPE (0,-27,20,D)

The Binary Output Tape

SABR outputs each machine instruction on binary output tape
as a 16-bit word contained in two 8-bit frames of paper tape. The
first four bits contain the relocation code used by the Linking
Loader to determine how to load the data word. The last 12 bits
contain the data word itself.
T

RELOCATION
HIGH ORDER OF
CODE __._
DATA WORD
...I..
__._
...I..
...I..
--.--."T
T
"T
_._LOW_._ ORDER Of DAIA w_._oRD _._

FIRST FRAME
SECOND FRAME

The assembled binary tape is preceded and followed by leader/
trailer code (code 200). The checksum is contained in the last two
frames of tape before the trailer code. It appears as a normal 16-bit
word, as shown below.
T

0
_._

T
__I

-1
"T
"
HIGH ORDER OF
CHECKSUM
__._
__I

LOW ORDER OF DATA WORD
l

...I..

FIRST FRAME

...I.

SECOND FRAME

All assembled programs have a relative origin of 0200.
LOADER RELOCATION CODES
The four-bit relocation_ codes issued by SABR for use by the
Linking Loader are explained below. The codes are given in octal.
00
Absolute
Load the data word at the current
a , loading address. No change is required.

2-45

5277

L™p

LOC

/~~ERE

LOC IS

/AT 0·177
/CURHEl\JT

0376

Simple
Relocation

0520 01

COF'
PAGE)

Add the relocation constant to the
word before loading it. (The relocation constantis 200 less than the
actual address where the first word
of the program is loaded.) Items
with this code are always program
addresses.

LOC2

In the above example, LOC2 is at
relative address 0520. If ·the first
word of the program (relative address 0200) is. loaded at 1000,
then the actual address of A is
1176 and location 1176 will be
loaded with the value 1320, which
will be the actual address of LOC2
when loaded.
03

External
Symbol
Definition*

The data word is the relative address of an entry point. Before entering this definition in the Linkage
Tables so that the symbol may be
referenced by other programs at
run-time, the Linking Loader must
add the relocation constant to it.
The six frames of paper tape following the two-frame definition are
the stripped ASCII code for the
symbo•.

* Does not appear in assembly listings.
2-46

ADDRESS

ADDRESS LOW ORDER
L

c
2
SPACE
SPACE

Re-origin*

Change the current loading address
to the value specified by the data
word plus the relocation constant.

CDP
Current

The data word is always a 6201
(CDF) instruction which has been
generated automatically by SABR.
The code 05 indicates to the Linking Loader that the number of the
field currently being loaded into
must be inserted in bits 6-8 before
loading.

0300
0 301

6201 05
1776

TAD LOC2
/WHERE LOC2 IS
/OFF PAGE SO
/THAT THE TAD
I INSTR.· MUST
I INDIRECT

0376

0520 01

If the orogram containing this code

is being loaded into field 4, relative
location 0300 will be loaded with
6241.
Such an instruction is ref erred to
in this document as CDF Current.
It is generated automatically by

* Does not appear in assembly listings.
2-47

SABR when a direct reference instruction must be assembled as an
indirect, and there is the possibility
that the current data field setting is
different from the field where the
indirect reference occurs.
06

Subroutine
Linkage
Code

The data word is a special constant enabling the Linking Loader
to perform the necessary linking
for an external subroutine call.
(c.f., CALL Pseudo-op). The
structure of the data word is shown
below.
BITS 0-5.

BITS 6-11
LOCAL PROGRAM
NUMBER ASSIGNED
TO THE EXTERNAL
SUBROUTINE
BEING CALLED

NUMBER OF
ARGUMENTS
FOLLOWING
THE CALL

Before the 12-bit, two-part code
word is loaded into memory, a
global external number will be substituted for the local external symbol number in the right half of the
data word.
0200
0201

4033
0307 06

CALL 3,SUB
ARG X
ARG Y
ARG Z

Here, SUB has been assigned the
local number 06 during assembly.
At loading time this number will
be changed to the global number
(for, example, 23) which is assigned to SUB. In this example,
0323 would actually be loaded at
relative address 0201.
2-48

Leader/Trailer*
and
Checksum

This code represents normal
leader/trailer. The checksum is
contained in the last two frames
of paper tape preceding the trailer
code.

High Common*

The data word is the highest location in Field 1 assigned to common storage by the program. This
item will occur exactly once in
every binary tape and it must be
the first word after the leader. If
no common storage has been allocated in the program, the data
word will be 0177.

Transfer*
Vector

Signifies that reference to ah external symbol occurs in the assembled program. The 12-bit data
word is meaningless. The next six
frames contain the ASCII code for
the symbol.
The Linking Loader uses this definition to create a transfer table,
whereby local external symbol
numbers assigned during assembly
of this particular program can be
changed to the global external
symbol number when several programs are being loaded.

Sample Assembly Listings
The following examples are offered to illustrate many of the
features and formats of the SABR Assembler. Loading and operating instructions immediately follow this section.
When a multiple word instruction occurs, the actual instruction
line is typed beside the first instruction.

* Does not appear in assembly listings.
2-49

6201 0 5
5774
7106
7006
7006

0650
0651
0652
0653
0654

LOC2,

JMP NAME

/OFF PAGE

CLL RTU RTL; RTL

When there is an erroneous instruction, the error flag appears
in the address field. The instruction is not assembled.
0700

7200

N2,

0701

7402

CLA
CLL SKP
HLT

The page escape and literal and off-page pointer table are typed
with nothing except the correct address, value and loader code.
0770
0771
077,2
0773
0774
0775
0776

7006
7500
5376
5377
0200 01
0020
7410

0 7..7 7

7410

N3,

RTL
SMA

/SKP TO lST LOC./NEXT PAGE CAC IS
/NOT MINUS)
/SKP TO 2ND LOC./NEXT PAGE CAC IS
/MINUS)

Locations 0772, 0773, 0776 and 0777 make up the page escape
since the last instruction is a skip instruction (SMA). Refer to the
sectiop concerning Page Escapes.
The following program has been assembled and listed. It cannot
be run _without first debugging and editing it.
During the first _pass, SABR outputs the binary tape and prints
error messages as they occur. In this case, none of the errors are
fatal, and assembly continues. The symbol table is printed, and
undefined symbols, external symbols, or any other special types of
symbols which cannot be determined until the end of the pass
are flagged in the symbol table.
_
The optional second pass of the As_sembler produces a listing.
The 4-digit first column contains the octal address, while the
2-50

second column contains the octal code for each line of instructi6ns.
Errors are also printed during the listing pass at the line in which
they occur. Meanings of error codes are described later in the
chapter.
The reader is also referred to Demonstration Program Using
Library Routines.

C AT

PUNCH +000 3

COUNT
DEC IMA
LT
MAIN
MESG
ORG
PT APE
PUNCH
REF
RPT
START
TYPE

0302
0000UN'{)F
026LJ
0000EXT
02LJ3
0303
0201EXT
027LJ
0177ABS
0267
0205
0000EXT
/PROGRAM TO PUNCH RIM FORMAT PAPER TAPES

6026
6021
0177
0200

0000

0201
(Jl202

0000
0000

020 3
0 20 Lj

1377
3302

020 5
0206
0207
0210

130 3
7132
7012
7012

PTAPE,

START,

OPDEF PLS 6026
SKPDF PSF 6021
ABSYM REF 177
ENTRY MAIN
DECIMAL
LAP
BLOCK 2

/DEFINE HI SPEED
I I OTS

/PUNCH LEADER

/TAPE- C200 CODE)
TAD C-32
132 LOCATIONS
DCA COUNT
OCTAL
TAD ORG
CLL CML RTR;RTR;RTR

2-51

0 211
0 212
0213
0 214
0215
0216
0 21 7
0220
0221
0222
0223
0 224
0225
0226
0227

0376
4274
130 3
0376
427 4
1703
7112
7012
7012
0375
4274
170 3
0375
4274
2303

AND
JMS
TAD
AND
JMS
TAD
CLL

0230
0231
0232
0233
0 234
0235
0236
0237
0 240

2302
520 5
40 33
0102 06
6201 05
0243 01
4264
7404
3303

ISZ COUNT
JMP START
CALL 1, TYPE
ARG MESG

0241.
0242

7402
5774

HLT
JMP MAIN

0243
0244
0245
0 246
0 247
0250
0251
0252
0253
0 254
0255
0256
0257
0260
0261
0262
0263

240 1
2005
4020
2516
0 310
0 504
5640
0 516
240 5
2240
1722
1107
11 1 6
40 4 6
400 3
1716
2456

MESG,

TEXT "TAPE PUNCHED. ENTER OR I GIN & CONT.

0 264

0000

LT,

0265
0266
0267
0270
0271
0272
0273

1373
3302
1372
4271-!
2302
5267
5664

AND
JMS
TAD
ANC
JMS
INC

Cl77

PUNCH
ORG

/PUNCH LEAD ING
/DIGITS OF ADDRESS
( 1 77
/PUNCH SECOND
PUNCH
/DIGITS OF ADDRESS
I ORG
/NOW PUNCH CONTENTS
RTR;RTR;RTR /OF THAT LOCATION
C77

PUNCH
I ORG
C77

PUNCH
ORG

JMS LT
OSR
DCA ORG

RPT,

OCTAL
TAD C-40
DCA COUNT
TAD C200
JMS PUNCH
ISZ COUNT
JMP RPT
JMP I LT

2-52

/GET SECONC DIG ITS
/OF THAT LOCATIO~
/PO INT TO NEXT
/CORE LOCATION
/DONE YET?
/NO
/YES, TYPE MESSAGE

/END ING 200 CODE
/GET NEW ADDRESS
/FROM SWITCH REGISTER
/PUT IT IN ORG
/PAUSE
/PUNCH NEW TAPE

132 FRAMES OF

/LEADER/TRAILER
/PUNCH IT
/DONE?
!NO

/RETURN

0274
0275
0276

0000
6026
6021

0277
0300
0 301

4045
7410
5674

0 302
0303
0304
030 5
0 372
0373
0375
0 376
0377

0000
7300
4040
0003 06
0200
7740
0077
0177
7746

PUNCH,

COUNT,
ORG,

0
PLS
PSF
JMP
JMP

/PUNCH

/WAIT FOR FLAG

• -1
I

PUNCH

/EXIT

0
7300
RETRN PTAPE

END

SABR Programming Notes
OPTIMIZING SABR CODE
There are generally two types of programmers who will use the
SABR Assembler-those who like the convenience of a pageboundary-independent code and need not be concerned with program size, and those who need a relocatable assembler, but are
still very location conscious. These optimizing hints are directed
to the latter user.
One way to circumvent the cost of non-paged code is to make
use of the LAP (Leave Automatic Paging) pseudo-op and the
PAGE pseudo-op to force paging where needed. This saves 2 to
4 instructions per page by elimination of the page escape. In addition, the fact that the program . ,must be properly segmented may
save a considerable amount.
Extra core may be reduced by eliminating the CDF instructions
which SABR inserts into a program. This is done by using "fake
indirects". Define the following op codes:
2-53

OPDEF AND I 0L!00
OP DEF TAD I 1 L!00
OPDEF ISZI 2L!00
OP DEF DCA I 3L!00

These codes correspond to the PDP-8 memory reference instructions but they include an indirect bit. The difference can best be
illustrated by an example:

If Xis off-page, the sequence:
SZA
DCA X

LABEL,

is assembled by SABR into:
LABEL,

SZA
JMS L!5
SKP
DCA I CX)

or four instructions and one Ii teral.
The sequence:
PX,

LAREL,

SZA
DCAI PX

assembles into three instructions for a saving of 40 percent. Note,
however, that the user must be sure that the data field will be correct when the code at LABEL is encountered. Also note that
SABR assumes that the Data Field is equal to the Instruction Field
after a JMS instruction, so subroutine returns should not use the
JMP I op code.
The standard method to fetch a scalar integer argument of a
subroutine in SABR is:
2-54

DUtv_MY X
0200
0201
0202
0203
0204
0205
0206
0207
0 210
(7) 211
0212
(i121 3
0 21 4
0215
0216
0 21 7
0220
0 221
0222

0000
00100
0000
00(7)0
00(7)0
4067
0203 CH
1407
32(7) 1
2204
40 67
0203 01
1407
3202
2204
40 67
0201 01
140 7
3200

IARG,

RLCCF 2

SUBB,

RLOCK 2
TAD I SUBB
DC.A x
INC SUBF:#
TAD I SUEf:
DC.A X#
INC SUER#
TAD I x
DCA

IARG

This is the method the FORTRAN compiler uses, and although
it is standard, it is also the slowest. This code requires 19 words
of core and takes several hundred microseconds to execute.
The fastest way to pick up arguments within a SABR coded
external subroutine is as follows (this takes approximately one
fifth of the time of the previous
. method and four less locations) :
.

0200
0 201
0202
0203
0204
0205

0000
0000
0000
1201
3205
7402

0206
0207
0210
0 211
0212
0213
0 214

1602'
3214
2202
1602
3200
2202
7402

021 :>
0 216

1600
3200

IARG,
SUBR,

0
BLOCK 2

x 1,

TAD SUER
DCA Xl
HLT

x2,

TADI SUER#
DCA X2
INC SUER#
TADI SUBR#
DCA IARG
INC SUER#
HLT
TADI IARG
DCA IARG

2-55

/REPLACED
/JW CDF

/REPLACED
/BY CDF

To pick up multiple arguments, the locations from Xl to X2+ f
inclusive can be made into a subroutine.
CALLING THE OS/8 USR.
AND DEVICE HANDLERS
· One important point to remember is that any code which calls
the USR must not reside in locations 10000 to 11777. Therefore,
any SABR routine which calls the USR must be loaded into a field
other th~n field 1 or above location 2000 in field 1. To call the
USR from SABR use the sequence:
CPAGE N
6212
JMS 7700
REQUEST
ARGUtt;:ENTS
ERROR RETURN

/N=7+C# OF ARGUMENTS)
IC IF 10
/OR 200 IF USR IN CORE
/OPTIONAL DEPENDING ON RF.QUEST
/OPTIONAL DEPENDING ON REQUEST

To call a device handler from SABR use the sequence:

HAND,

CPAGE 12
6202
JMS I HAND
FUN CT
ADDR
BLOCK
ERROR RETURN
SKP
0

/10 IF "HAND" IN PAGE 0
/CIF 0
/DO NOT USE JMSI

/"HAND" MUST BE ON SAME PAGE
/A.S CALL, OR IN PAGE 0

Loading and Operating SABR
Procedures for loading SABR and assembling a source program
are given below. See Appendix A for instructions on the use of
the Binary Loader. Loading and operating instructions for OS/8
SABR are contained in Chapter 9 of Introduction to Programming.
1. Make sure the Binary Loader is in memory, in field n.
2. Set switches 6-8==n (Instruction field), and switches 9-11 ==O
(Data field).
3. Press EXTD ADDRess LOAD.
4. Set the Switch 'Register==7777.
5. Press ADDRess LOAD.
6. Insert the SABR binary tape into the reader.

2-56

7. If using the high-speed reader, depress Switch Register
Bit 0.
8. Press CLEAR and CONTinue.
9. SABR will now be loaded into memory by the Binary
Loader; portions of SABR will load into field 0 and field 1.
ASSEMBLY PROCEDURE
It is assumed that the programmer has written his program in
SABR language and punched this source program on paper tape in
·ASCII code. The source tape may have been split into several
separate tapes by placing a PAUSE statement at the end of each
section except the last. The last tape must have an END statement
at the end.
After SABR has been loaded into memory, it is used to assemble
the source program. In Pass 1 the relocatable binary version of the
user's program is created and, at the end of this pass, the symbol
table is either typed or punched, according to whether the user has
specified that his listing is to be typed or punched. Pass 2 is the listing pass. The assembly is carried out as follows:
1. Set switches 6-8=0 (Instruction field), and switches
9-11 =O (Data field).
2. Press EXTD ADDRess LOAD.
3. Set the Switch Register==0200.
4. Press ADDRess LOAD, CLEAR, and CONTinue.
5. SABR now types an identification label and a sequence of
two or three questions:
PDP-8 SABR DEC-08-A2D2-16
HIGH SPEED READER?
HIGH SPEED PUNCH?
LISTING ON HIGH SPEED PUNCH?
These questions must be answered with Y if the answer is
yes. Any other answer is assumed to be no. The third question is typed only if the second is answered Y. If the third is
answered Y, both the symbol table and the listing pre
punched on the high-speed paper tape punch. Otherwise,
they are typed on the teletypewriter. The user need not wait
for the full question to be typed before responding.
6. As soon as SABR has echoed the user's response to the last
question, turn on the punch device and, if it is being used,
2-57

9.
10.

11.
12.

the Teletype reader. If the low-speed reader is used,
the error message E indicates that the user has waited too
long before turning the reader on and must begin again. If
using the high-speed reader, the tape must be positioned in
the reader before answering the last question.
At this point, Pass 1 begins. SABR reads the source tape
and punches the binary tape. After the binary tape has been
completed, SABR types or punches the program symbol
table.
If the source tape is in several sections (separate tapes with
P AUSEs at the end of all except the last), SABR halts at
the end of each section. At this point, insert the next section
in the reader and then press CONTinue.
At the end of Pass 1, SABR halts.
If an assembly listing is desired, reposition the beginning of
the source tape in the reader, and if using the Teletype
reader, set it to START, and then press CONTinue.
At the end of Pass 2, SABR again halts. To restart SABR
for assembling another program, press CONTinue.
To restart SABR at any time, press HALT, set the Switch
Register==0200, press ADDRess LOAD, CLEAR, and
CONTinue. The first pass must always be repeated.

PROCEDURE FOR USE AS FORTRAN PASS 2
In addition to its status as a stand-alone assembler, SABR
serves as pass 2 of the SK FORTRAN compiler. For this purpose,
SABR procedures differ slightly. The FORTRAN compiler, in one
pass, converts the user's FORTRAN source program into a symbolic
source program containing standard PDP-S mnemonics. SABR
then converts the symbolic tape into a relocatable, binary-coded
program. Methods for assembling FORTRAN source tapes with
SABR are contained in Chapter 1.
The Linking Loader
Relocatable binary program tapes produced by SABR assembly
are loaded into memory by using the SK System Linking Loader.
The Linking Loader is capable of loading and linking a user's
program and subprograms in any fields of memory, and is even
capable, in a special way, of loading programs over itself. It also
has options which give storage maps and core availability.

2-58

The Linking Loader requires a PDP-8 series computer with at
least 8K words of core memory. Either high-speed or Teletype
paper tape input is acceptable; however, _a high-speed reader is
highly recommended.
The software requirements are:
1. Binary paper tap¢ copy of the Linking Loader (DEC-08A2C3-PB) (The Linking Loader is pre-built into the
OS/8 Operating System.)·
2. Relocatable binary paper tape copies of both Part 1 and
· Part 2 of the 8K System Library
3. The relocatable binary paper tapes of the· user's ·awn program and subprograms which have been produced by assembling his programs with SABR.
OPERATION
•
Generally. speqking, the Linking Loader is capable of loading
any number of user and Library programs into any field of PDP-8
memory. These programs are loaded consecutively via the highspeed reader (or the Teletype reader). The choice of which field to
load each program into is a switch register option. Usually, several programs may be loaded into each field. Because of the space
reserved for the Linkage Routines, the ·available space in field 0 is
three pages smaller than in all other fields.
Any common storage reserved by the program being loaded
is allocated in field 1 from location· 0200 upwards. The space reserved .for common. is obviously subtracted from the available
-loading area in field 1. The program reserving the largest amount
of common storage must be loaded first.
The Linking Loader uses the following special method to enable
loading data over itself. When the Linking Loader encounters data
which must be loaded over itself, it punches this data onto paper
tape in RIM format. Then, after the user has finished loading all
his relocatable binary program tapes, he simply loads the RIM
format tape using the standard RIM loader.
The Run-Time Linkage Routines which are necessary to execute
SABR programs are automatically loaded into the required areas
of every field by the Linking Loader as a part of its initialization.
For the user, the only required knowledge of these routines is the
particular areas of core they occupy.
2-59

LINKAGE ROUTINE LOCATIONS
Because the Library' Link'ige Routines must be in core when
SABR assembled programs -tire run, certain care locations are not
available as follows:
Field 0
Field 0, l, 2, ...

Locations 0200-0777 .
Locations 0007 and 0033-0073
Locations 0007 and 0033-0124 if using
the device independent I/0 options
or the CHAIN subroutine in OS/8
FORTRAN.
Thus in every field of memory the following page 0 locations
are available to the user:
0000-0006
for interrupts, debugging, .etc.
0010-0017
auto .. index registers*
0023-0032
arbitrary
0074-0177
arbitrary
0125-0177
if using the device independent 1/0
option available in OS/8 FORTRAN.
*Location 10 is not available in OS/8
Reserved Locations
Locations 20, 21, 22 in field 1 are used for the Floating-Point
Accumulator. The user should use these locations with great care.
When using the Library routines, locations 20-32 in the field where
the routines reside are used for temporary storage by the routines.
Locations 176 and 177 in the field where the J/O handler routines
(IOH) reside are used for temporary storage by the I/0 handler.
The 8K System Library subprograms, which may be used by any
SABR program, are loaded in the same way as other relocatable
binary programs. Only those library programs which the user's
programs actually call need to be loaded. /
SWITCH REGISTER OPTIONS
During the loading operation with the Linking Loader, two i1ser
options are available to obtain information about what has already
been loaded. The switch register is used to select these options.
Either option may be selected after any program has finished
loading.
WARNING
The Teletype punch must be at OFF or FREE
before, selecting these options.
2~60

The switch register bits used are as follows:
BIT 0 == 1 selects the Core Availability option;
BIT 1 1 selects the Storage Map option.

The Core Availability option causes the number of free pages of
memory in every field of memory to be typed in a list on the Teletype. For example, if the user has a 16K configuration, a list like
the following might be typed.
0002
0010
0030
0036

(number of free pages in field 0)
(number of free pages in field 1)
(number of free pages in field 2)
(number of free pages in field 3)

The number of pages initially available in field 0 is 003 3 and in all
other fields is 0036.
The Storage Map option causes a list of all program entry points
to be typed, along with the actual address at which they have been
loaded. The entry points of programs which have been called but
which have not been loaded are also listed along with a U flag for
undefined. Such flagged programs must be loaded before execution
of the user's programs is possible. The Core Availability list is
automatically appended to the Storage Map. A sample is shown
below.
MAIN
READ
WRITE
IOH

SET ERR
ERROR
TTY OUT
HS OUT
TTY IN
HSIN
FDV
CLEAR
IFAD
FMP
ISTO
STO
FLOT
FAD
DIV

10200
01055
'2J'1066
0 30 31
00000 u
00000 u
00000 u
00000 u
00000 u
00000 u
04722
05247
0 51 31
04632
05074
04447
0 5210
040 10
00000 u

2-61

LOADING THE LINKING LOADER
The Linking Loader must be loaded into the highest field of
memory. Loading instructions for the OS/8 Linking Loader are
contained in Chapter 9 of Introduction to Programming.
1. Make sure the Binary Loader is in memory, for example, in
field m, and let h represent the number of the highest field
in the user's configuration.
2. Set switches 6-8=m (Instruction field) and switches 9-11 =h
(Data field).
.
3. Press EXTD ADDRess LOAD.
4. Set the Switch Register==7777.
5. Press ADDRess LOAD.
6. Place the binary paper tape of the Linking Loader in the
reader.
7. If using a high-speed reader, depress Switch Register Bit 0.
8. Press CLEAR and CONTinue.
LOADING RELOCATABLE PROGRAMS
The Linki~g Loader is used to load the user's relocatable programs and SK Library subprograms as outlined below.

NOTE
The program or subprogram which uses the
largest amount of common storage should
be loaded first. (The Library subprograms
do not use common.)

1. After the Linking Loader has been loaded into the highest
memory field, h, set the switches as follows: switches 6-8==h
(Instruction field) and 9-11 ==h (Data field).
2. Press EXTD ADDRess LOAD.
3. Set the Switch Register=0200.
4. Press ADDRess LOAD.
5. Place the relocatable binary tape for the first program to
be loaded in the reader. Position the tape with leader code
in the reader.
6. Set Switch Register to 0000. Then, if loading via the Teletype reader is required, raise Switch Register bit 6. If the
configuration does not include a high-speed punch, raise
Switch Register bit 7. Finally, set Switch Register bits 9-11
to the number of the field into which the first program or
subprogram is to be loaded.
2-62

SWITCH REGISTER

~ I ~ I I 1 1 1 ~ I ~ I I: I1~ I I
2

+·

LsTORAGE MAP
LcoRE PAGES

11
1

LOADING FIELD

PUNCH (TELETYPE)
READER (TELETYPE)

Example:
If the user wishes to load his first program into field 3, and
if he has no high-speed I/ 0 device, then he should set the
switch register to 0063 before the next step.
7. Press CLEAR and CONTinue.
8. The Linking Loader types out an identification label, and
the user's relocatable binary program will be loaded:
PDP-8 LINKING LOADER DEC-08-A2C3-07
When loading is completed, the Linking Loader halts.
9. The user may now either load another program or select
one of the options in steps 11 and 12.
10. To load another program, insert the program relocatable
binary tape in the reader, set Switch Register/bits 9-11 to
the number of the field the program is to be loaded into,
and then press CONTinue.
11. To select the Core Availability option, set Switch Register
bit 0 = 1, and press CONTinue.
12. To select the Storage Map option, set Switch Register bit
1 == 1, and press CONTinue. *
If the Teletype punch is turned on for possible RIM format
data punching, as explained earlier, ensure that it is turned
off before selecting either of the options. Turn it on again
after the typing of ·the options is completed.
13. The user may continue loading more programs as in step
10 after using either of the options.
Any time the Linking Loader halts, the user may access memory
directly via the DEPosit and EXAMine 'console switches. After
this is done the Linking Loader may be restarted via the console
switches at location 7200 (in the highest field, where the Linking
Loader resides).

* All other Switch Register bits are irrelevant.
2-63

Error Messages
SABR
Because SABR is a one-pass automatic paging assembler, object
errors are difficult to correct. If there are errors in the source, the
assembled binary code will be virtually useless. Both errors E and
S are fatal, and assembly halts when they are encountered. The
other types of errors are not fatal, but they cause the line in which
they occur to be treated as a comment and thus essentially ignored.
An address label on such a line will remain undefined and no space
is reserved in the binary output for the erroneous data.
During the assembly pass, error messages are typed on the tele. type as they occur.
C

LOC

+0004

This means that an error of type C has occurred at the fourth
instruction after the location tag LOC. This line count includes
comment lines and blank lines. ·
During the listing pass, the error is typed in the address field
of the instruction line.
The following error messages may occur.
A
C

Too many or too few ARGs follow a CALL statement.
An illegal character appears on the line. This could possibly
be an 8 or 9 in an octal digit string or an alphabetic character in a digit string.
A symbol is multiple defined (occurs only during Pass 1).
It is impossible to resolve multiple definitions during Pass
2; therefore, listings of programs which contain multiple
definitions will have unmarked errors.
An illegal syntax has been used. Below are listed the types
of illegal syntax that may occur.
1. A pseudo-op with improper arguments.
2. A quote mark with no argument.
3. A non-terminated text-string.
4. A memory reference instruction with improper address.
5. An illegal combination of micro-instructions.
2-64

E
S

There is no END statement.
This error message means either one of four things:
1. The symbol table has overflowed. This can be corrected by using fewer symbols, using shorter symbols,
or by breaking the program into smaller parts.
2. Common storage has been exhausted.
3. More than 64 different user-defined symbols have
occurred in a core page.
4. More than 64 external symbols have been declared.

One further type of error may occur. This is an undefined symbol. Because SABR is a one-pass assembler, an undefined symbol
cannot be determined until the end of the assembly pass, so the
error diagnostic UNDF is given in the symbol table listing.
Codes flagged beside symbols in the symbol table are explained
in the section concerning the symbol table. ·
In addition to the SABR error messages already described, OS/8
SABR contains the following:
D

A device handler has returned a fatal error condition.

/L or /G option was indicated, but the LOADER.SY file
does not exist on the system device.

No symbol table is being produced, but there is at least one
undefined symbol in the program. The name of the first
undefined· symbol found appears in the error message.

LINKING LOADER
If during the process of loading a program or subprogram the
Linking Loader encounters an error, the user is notified by an error
message; the partially loaded program or subprogram is ignored,
removed from the field, and core is freed. The error messages are
typed out in the form:
ERROR

XXXX

where XXXX is the error code number.
2-65

Table 2-2

Linking Loader Error-Codes

Error Code

Explanation

0001

More than 64 10 subprogram names have been
seen by the Loader ( 6410 subprogram names is
the capacity of the Loader's symbol table).
The current field is full, or load was to nonexistent memory.
The current subprogram has too large a common storage assignment. (Subprogram with
·largest common storage declaration must be
loaded first.) This is a semi-fatal error. R~
initialize the Linking Loader as explained on
page 15-87 and reload the programs in the
proper order.
Checksum error in input tape. If the error persists, re-assembly is necessary.
Illegal Relocation Code has been encountered.
This can occur only if the relocatable binary
tape is bad or if the user is using it improperly
(e.g., not starting at the beginning of the tape,
or reader error, or punch error). If the error
persists, reassembly is necessary.

0002
0003

0004
0005

The OS/8 Linking Loader includes these additional erro_r codes:
Error Code

Explanation

0000

/l or /0 specified too late. Refer to Chapter 9

0006
0007

0010
0011

of .Introduction to Programming.
An output error has occurred while reading a
binary file.
An input error has occurred (either a physical
device error or an attempt to read from a writeonly device).
No starting address has been specified and there
is no entry point named MAIN.
An error occurred while the Loader was trying
to load a device handler, or no /H was specified
(see Chapter 9).
2-66

0012

1/0 error on system device.

Recovery from errors 2, 4, and 5 is accomplished by repositioning the tape in the reader to the le,ader code at the beginning of the
subprogram and then pressing CONTinue. When attempting to
recover from one of these errors, no other program should be
loaded before reloading the program which caused the error. Obviously, on Error 2 a different field should he selected before pressing CONTinue.
The entire loading process may be restarted at any time by reinitializing the Linking Loader via the console switches. To do this,
set switches 6-8==h (the field where the Linking Loader resides),
switches 9-11 ==h, and press EXTD ADDRess LOAD. Then set
the Switch Register==6200, and press ADDRess LOAD, CLEAR,
and CONTinue.
LIBRARY PROGRAMS
During execution, the Library programs check for certain errors
and type out the appropriate error messages in the form:
XXXX ERROR AT LOC NNNN
where XXXX specifies the type of error, and NNNN is the location of the error. When an error is encountered, execution stops,
and the error must be corrected.
When multiple error messages are typed, the location of the
last error message is relevant to the user program. The other error
messages are relevant to subprograms called by the statement at
the relevant location.
Table 2-3

Library Error Messages

Error Message

Explanation

ALOG
ATAN
DIVZ
EXP
FIPW
FMTl
FMT2
FMT3
- FMT4
FMT5

Attempt to compute log of negative number
Result exceeds capacity of computer
Attempt to divide by 0
Result exceeds capacity of computer
Error in raising a number to a power
Multiple decimal points
E or . in integer
Illegal character in I, E, or F field
Multiple minus signs
Invalid FORMAT statement
2-67

Table 2-3 (Con't)

Library Error Messages

Error Message

Explanation

FLPW
FPNT

Negative number
raised to floating power
I
Floating-point error; rnay be caused by
division by zero; floating-point overflow; attempt to fix too large a number.
Attempt to take root of a negative number

SQRT

•

OS/8 includes, in addition, the error message:
USER ERROR 1 AT 00537

which means that the user tried to referen9e an entry point of a
program which was not loaded.
To pinpoint the location of a Library execution error:
1. From the Storage Map, determine the next lowest pumbered
location (external symbol) which is the entry point of the
program or subprogram containing the error.
2. Subtract in octal the entry point location of the program or
subroutine containing the error from the LOC of the error
in the error message.
3. From the assembly symbol table, determine the relative address of the external symbol found in step· 1 and add that
relative address to the result of step 2.
4. The sum of step 3 is the relative -address of the error, which
can then be compared with the relative addresses of the
numbered statements in the program.

Demonstration Program Using Library Routines
The following demonstration program is a SABR program showing the use of the library routines. The program was written to add
two integer numbers, convert the result into floating-point, and.
type the result in both integer and floating-point format. The source
program was written using the S.ymbolic Editor, assembled with
SABR, and loaded with the Linking Loader, under the OS/8
Operating System. (An example of a FORTRAN program
2-68

compiled and then assembled with the paper tape SABR system
is contained in the section, Demonstration Program, in Chapter 1.)
A

c
D

FLOAT
FORMT
!OH
N

OPEN
START
STO
WRITE

0257
0260
0261
0262
0000EXT
0240
0000EXT
0256
0000EXT
0200EXT
0000EXT
0000EXT

ENTRY START
START,

CALL 0,0PEN

0200
0201

4033
0002 06

0202
0203
0204
0205
0206

1257
1260
3261
4033
0103 06

TAD A
TAD B
DCA C
CALL !,FLOAT

0207
0210
0 211
0212
0213
0214
0215
0216

6201
0261
4033
0104
6201
0262
4033
020 5

ARG C

0217
0220

/INITIALIZE
II 10 DEV ICES
/COMPUTE C=A+B
/CONVERT TO
/FLOATING POINT

05
01

CALL 1,STO
06
05
01

ARG D
CALL 2,WRITE

/INITIALIZE

6201 0 5
0256 01

ARG N

I IIO HANDLER
/DEVICE NUMBER

0221
0222

6201 05
0240 01

ARG FORMT

/l =TELETYPE
/FORMAT SPEC!-

0223
0224

40 33
0106 06

CALL 1,IOH

/FICATION
/TYPE INTEGER

0225
0226
0227
0230

6201 0 5
0261 01
4033
0106 06

ARG C

0 231
0232
0233
0234
0235
0236
0237

620 1 0 5
0262 01
4033
0106 06
6211
0000
7402

ARG D

/NUMBER
CALL 1,IOH

/TYPE FLOATING
/PO INT NUMBER

CALL 1,IOH
ARG 0
HLT

2-69

/COMPLETE THE I/O

0240
0241
0242
0243
0244
0245
0246
0247
0250
0251
0252
0253
0254
0255
0256
0257
0260
0261
0262
0263
0264

5047
2410
0540
0116
2327
0522
2340
0122
0547
5411
6554
0667
5662
5100
0001
0002
0002
0000
0000
0000
0000

FORMT,

TEXT "C'THE ANSWERS ARE',I5,F7.8)"

N,
A,
B,

1
2
2
0

BLOCK 3
END

The binary tape produced by the assembly was then run using
OS/8 with the following results:
THE ANSWERS ARE

2-70

appendix a
loading procedures

Initializing the system
Before using the computer system, it is goop practice to initialize
all units. To initialize the system, ensure that all switches and controls are as specified below.
1. Main power cord is properly plugged in.
2. Teletype is turned OFF.
3. Low-speed punch is OFF.
4. Low-speed reader is set to FREE.
5. Computer POWER key is ON.
6. PANEL LOCK is unlocked.
7. Console switches are set to 0.
8. SING STEP is not set.
9. High-speed punch is OFF.
10. DECtape REMOTE lamps OFF.
The system is now initialized and ready for your use.
Loaders
READ-IN MODE (RIM) LOADER
When a computer in the PDP-8 series is first received, it is nothing more than a piece of hardware; its core memory is completely
demagnetized. The computer "knows" absolutely nothing, not even
how to receive input. However, the programmer can manually
load data directly into core using the console switches.
The RIM Loader is the very first program loaded into the computer, and it is loaded by the programmer using the console
A-1

switches. The RIM Loader instructs the computer to receive and
store, in core, data punched on paper tape in· RIM coded format
(RIM Loader is used ~to load the ,BIN Loader descrJbed below.)
There are two RIM loader programs: one is used when the input is to be from the low-speed paper tape reader, and the other
is used when input is to be from the high-speed paper tape reader.
The locations and corresponding instructions for both loaders are
listed in Table A-1.
The procedure for loading (toggling) the RIM Loader into core
is illustrated in Figure A-1.
Table A-1.

RIM Loader Programs

Instruction
Location

Low-Speed Reader

High-Speed Reader

7756
7757
7760
7761
7762
7763
7764
7765
7766
7767
7770
7771
7772
7773
7774
7775
7776

6032
6031
5357
6036
7106
7006
7510
5357
7006
6031
5367
6034
7420
3776
3376
5356
. 0000

6014
6011
5357
6016
7106
7006
7510
5374
7006
6011
5367
6016
7420
3?°76
3376
5357
0000

After RIM has been loaded, it is good programming practice to
verify that all instructions were stored properly ... This can be done
by performing the steps illustrated in Figure A-2, which also
shows how to correct an incorrectly stored instruction.
When loaded, the RIM Loader occupies absolute locations 7756
through 7776.
A-2

INITIALIZE

SET ROTARY
SELECTOR .SWITCH
TO MD

SET SWITCHES 6-8
TO DESIRED
INSTRUCTION FIELD*

*DECTAPE USERS SHOULD
LOAD RIM INTO FIELD 0

PRESS
EXT LOAD ADDR

SET SR
TO 7756

PRESS
ADDR LOAD

SET SR=
FIRST INSTRUCTION

PRESS DEP

SET SR=
NEXT INSTRUCTION

PRESS DEP

RIM IS LOADED

_Figure A-l.

Loading the RIM Loader

A-3

INITIALIZE

SET ROTARY
INDICATOR
SWITCH TO. MO

SET SWITCHES
6-8 TO FIELD IN
WHICH RIM HAS
BEEN LOADED

PRESS
EXT · AODR LOAD

SET'SR=7756

PRESS
ADDR LOAD

PRESS EXAM

SET SR=MA-1

PRESS
ADDR LOAD
RIM IS LOADED
SET SR= CORRECT
INSTRUCTION

PRESS DEP

Figure A-2.

Checking the RIM Loader

BINARY (BIN) LOADER-.
The BIN Loader is a short utility program which2 . when in core,
instructs the computer to read binary-coded data punched on paper
tape and store it in core memory. BIN is used primarily to load the
programs furnished in the software package (excluding the loaders
and certain subroutines) and the programmer's binary tapes.
BIN is furnished to the programmer on punched paper tape in
RIM-coded format. Therefore, RIM must be in core before BIN
can be loaded. Figure A-3 illustrates the steps necessary to properly load BIN. And when loading, the input device (low- or highspeed reader) must be that which was ·selected when loading RIM.
A-4

- - - -i

See Figures

LOW-SPEED

- - - - - ! P U T LSR TO START

PRESS HALT

BIN LOADER
IS LOADED

Fiizurr

A-~

Loading the BIN Loader

A-5

c2-1,c2-2I

When stored in core, BIN resides on the last page of core, occupying absolute locations 7625 through 7752 and 7777.
BIN was purposely placed on the last page of core so that it
would always be available for use-the programs in DEC's software package do not use the last page of core (excluding the Disk
Monitor). The programmer must be aware that if he writes a
program which uses the last page of core, BIN will be wiped out when that program runs on the computer. When this
happens, the programmer must load RIM and then BIN before
he can load another binary tape.
Binary tapes to be loaded should be started on the leader-trailer
code (Code 200), otherwise zeros may be loaded into core, destroying previous instructions.
Figure A-4 lilustrates the procedure for loading binary tapes
into core.

A-6

LOAD BIN

- -

~ SEE FIGURE C2-3

LOW-SPEED READER

URN TTY TO LINE

PRESS CLEAR
AND CONT

PRESS CONT

OBJECT TAPE
IS LOADED

F:gure A-4.

Loading A Binary Tape Using BIN

A-7

appendix b
character codes
ASCII-1 1 Character Set
8-Bit
Character Octal

6-Bit
Octal

301
302
303
304
305
306
307

01
02
03
04
05
06
07

A
B

c
D
E
F
G
H
I
J
K
L

M
N

s
T

u
v

w
x

z
0
1
2
3
4
5
6

7
8
9

310

311
312
313
314
315
316
317
320
321
322
323
324
325
326
327
330
331
332
260
261
262
263
264
265
266
267
270
271

11
12
13
14
15
16
17
20
21
22
23
24
25
26
27
30
31
32
60
61
62
63
64
65
66
67
70
71

Decimal
Equivalent
(Al Format)

Character

96
160
224
#
288
$
352
%
416
&
480
544
(
608
)
672
*
736
+
800
'
864
928
992
/
1056
1120
1184
<
1248
1312
>?
1376
1440
@
1504
[
1568
1632
]
1696
t( t\ ):;
~(-)~
-992
Leader/Trailer
-928
LINE FEED
-864
-800 Carriage RETURN
SPACE
-736
RUBOUT
-672
Blank
'--608
BELL
-544
TAB
-480
FORM
-416

8-Bit
Octal
241
242
243
244
245
246
247
250
251
252
253
254
255
256
257
272
273
274
275
276
277
300
333
334
335
336
337
200
212
215
240
377
000
207
211
214

Decimal
6-Bit
Equivalent
Octal (Al Format)
41
42
43
44
45
46
47
50
51
52
53
54
55
56
57
72
73
74
75
76
77

The character in parentheses is printed on some Teletypes.

B-1

-96

33
34
35
36
37

-32
32
1760
1824
1888
1952
2016

-2016

1 An abbreviation for American Standard Code for Information Interchange.
'.!

-1952
-1888
-1824
-1760
-1696
-1632
-1568
-1504
-1440
-1376
-1312
-1248
-1184
-1120
-1056
-352
-288
-224
-160

appendix c
permanent symbol
table
The following are the elements of the PDP-8 instruction set
found in the SABR permanent symbol table. These instructions
are already defined within the computer. For additional information on these instructions and for a description of the- symbols
used when programming other, optional, I/0 devices, see the Small
Computer Handbook, available from the DEC Software Distribution Center.

INSTRUCTION CODES
Mnemonic Code

Operation

Memory Reference Instructions
AND
0000
Logical AND
TAD
1000
Two's complen1ent add
. ISZ
2000.
Increment and skip if zen.
INC
2000
Nonskip ISZ
3000
DCA
Deposit and clear AC
JMS
4000
Jump to subroutine
5000
Jump
JMP

Time (µ.sec.) i

2.6
2.6
2.6
2.6
2.6
2.6
1.2
Sequence·

Group 1 Operate Microinstructions (I cycle:.?)
NOP
7000
No operation
IAC
7001
Increment AC
RAL
7004
Rotate AC and link left one
RTL
7006
Rotate AC and link left two
RAR
7010
Rotate AC and link right one
RTR
7012
Rotate AC and link right two
CML
7020
Com plcmented link
7040
CMA
Complement AC
CLL
7100
Clear link
CLA
7200
Clear AC
1 Times are representative of the PDP-8/E.

:2 1 cycle is equal to 1.2 microseconds.

C-1

3
4
4
4

4
2
2
I

Mnemonic Code

Operation

Sequence

Group 2 Operate Microinstructions ( 1 cycle)
7402
Halts the computer
HLT
7404
Inclusive OR SR with AC
OSR
Skip unconditionally
SKP
7410
SNL
7420
Skip on nonzero link
SZL
Skip on zero link
7430
Skip on zero ·Ac
SZA
7440
7450
Skip on nonzero AC
SNA
Skip on minus Ac
SMA
7500
Skip on positive AC (zero is positive
SPA
7510

3
3
1
1
1
1
1
1
1

Combined Operate Microinstructions
CIA
7041
Complement and increment AC
STL
7120
Sentlinktol
STA
7240
Set AC to - 1

2, 3
1,2
2

Internal IOT Microinstructions
ION
6001
Turn interrupt processor on
IOF
6002
Disable interrupt processor
Keyboard/Reader (1 cycle)
KSF
6031
Skip on keyboard/reader flag
KRB
6036
Clear AC, read keyboard buffer
(dynamic), clear keyboard flags
Teleprinter I Punch ( 1 cycle)
fSF
6041
Skip on teleprinter/punch flag
TLS
6046
Load teleprinter I punch, print, and clear
teleprinterI punch flag
High Speed Reader-Type PR8/ E ( 1 cycle)
RSF
6011
Skip on reader flag
RRB
6012
Read reader buffer and clear reader flag
RFC
6014
Clear flag and buffer and fetch
character
High Speed Punch-Type PP8/E (1 cycle)
PSF
6021
Skip on punch flag
PLS
6026
Clear flag and buffer, load buffer and
punch character

C-2

PSEUDO-OPERATORS

The following is a list of the SABR assembler pseudo-operators.
ABSYM

ACH
ACM
ACL
ARG
BLOCK
CALL
COMMN

CPAGE
DEC IM
DUMMY

EAP
END
ENTRY

FOR TR
I

LAP
OCTAL

OPDEF
PAGE
PAUSE
REORG

RETRN
SKPDF
TEXT

C-3

INDEX
ABS,

2•3R

8in~ry,

function. 1•35
Absolute, 2•45
ABSYM PSPUrlo•op,

2-1~

AddressPs,
On~rnnd, 2•5
Algebraic on~rations, 1•6
Allocation,
Comt""nn storarJe,

1•69

functio~,

ALOG

1•35, 2•41
AiPhabetic characters, 2•2

A.lP.harrnmeric,
fiPld specitications, 1•15
fields, 1•1A
ANSI FORTRAN St~ndards, 1-~7
ARG pseurlo•op, 2-21
Arqurnents, 2-20

nummy, 1·30
Handlinq of, 2•2'
Passino suhr6utine, 2·24
Aritnmet1c,
Floatinq•point, 1•36, 2•37
tnteqer, 2•39
Arithmetic expression, 1•7
AritMmetic statements,
form, 1.•10
Array,
idPntif iers, 1•2R
suhscripts, 1•28
variables, 1-~
Arrays, 1•5, 2•39, 2•44
ca1cu1atina suhscrints of,
1•68

Penresentation of
n•dimensional, 1•68
Storaqe of, 1.•67
Two•dime~sionat,

exrionent, 1•66
mantissa, 1•6n
output tape, 2•45
relocatable oroqram
tapes, 1•55
81ock,
tiata, 1•39
two•wnrd, 2·24
number, 1•40, 1•41

BLOCK pseudo•oo, 2•17
Calculating subscriots of
arrays, 1•bR
CALL OPEN statemPnt, 1•27
CALJH
pseudo•oP,

2•21
statement, 1•33
Callina the 05/8 USR and
device handlers, 2·~6
CDf current, 2•47
CD~SKP

CHAIN subroutine, 1·39, 2•43
Chail"ling,
Device Ir~ependent 11n
and,

F'OPTRA?.J,
SABH,

1 •2

2•2

Characters,

1•68

AlPh~betic,

character set, B•1
eonstants, 2-5
stripoed format, 1•18
tPxt strings, 2•18

2•2

Numeric, 2•2
Soecial, 2•i.

Checkincr the PIM

l~ader,

A•4

Checksum, 2•45

ASSE:"mbler,

loadina thP SABR, 1~~2
operatina the SARP, 1•52
Assemhler ~utout,
Sunoressina, t•53
Asse~blina a sv~holic taoe,
1•53

Assemhly,

Leader/tr~11er

CHS, 2""3'7
CKTO subroutine,

CLf.AR,

and, 2•49
2•42

2•H

Closed subroutinesl 1•29
Code, Learler/trailer, 2•45
Corles,

B•t
rnstructior., C•l
J,oader H'location, 2•45
Numeric field, 1•16

control, 2•11
first pas$, 2-so
pa~e-by-paoe, 2•2A
Procedt.Jre, 2•57
seco~d pass, 2•50

Char~cter,

CommPnts,

ATAN,

1-9, 2•8,

1 - 3 5 , /. - 4 n
s 11 b r 0 u t i n e ,

AutoMatic paaina

~ode,

2•3

pseudo-op, 2•16
COMMO~ state~ent,
1•2B
Common storaoe, 1•56, ?,•16,

CO~MN

f u.n ct ion ,

, .. 4 4

1•37, ?•4.3

to a subroutine, 1•46
Chanqi~q the numeric
conversion mode, 2•12
Character codes, K•l
Character set,
ASCII, B•l

ASCII

IJ I b r a r y

Linkacre routine, 2•31

Cn z s T< P l1 ink age rout 1 n e , 2"' 31

7.-59
allcc,;11tinn,

2•29

X-1

1•69

Co"'piler,
error messaoes, 1•4R, 1•49
loadinq and operating th~~
1•46
suppressjng output, 1•47
Computed GOTC1, 1•24

Conditional Pseudo•oP, 2•f4
Conserving storaqe space,
1•29

Constants, 1•2, l•lO, 2•5
ASCII, 2·~
lio1. lnith, 1•3
Integer, 1 •2
"' ume r 1 e , 2 • 5
Real, 1•3

state~ent,

arquments, 1 .. 30
statement, 1•26
DUMMY,
pseudo•oP, 2•24
Linkage routine, 2•24
variables,
manipulating, 2•tn
DUMSU8 Linkage routine,
EAP pseudo•oP, 2•13

3•26

Control characters, 1-15, 1•20
Control ~tatements, 1•23
Co~version, Holl~rith, 1•20
Conversion mode,
Numeric, 2•6, '•12
Core avatlab!litY option,
1•57, 2•f>\
COS f1Jnction.• 1•35·, 2 . . 40
CPAGE pseurio•oo, 2•13
CTRidTAB,

Dummy,

2•32

Variabl~ storage and, 1•47
Constants anrl variables,
Reoresentation ot, 1•65

CONTINUE

nouble quotation marks, 2•5

1•B

(0, 2•6

Data,
hlocl<s, 1•39
qeneration, 2•17
transmission
specif !cation, 1•15
statements, 1•11
word, 2-115
OECJM pse11do•op, 2•5,
2•12

2•6,

DECtape,
for mat, 2•44
I/O roiitines, 1•39, ?•43
Defi~ition, symbol, 2·15
Demo~stration Prooram,
1-~P
CLibrarv Routines), 2•6B
Deviee designations, l•ll, 1•14
Oeviee handlers,
calling the OS/8 USR a~d,
2•56

Device Indepl'ndel'\t l/O al"ld
Cl'lainino, 1•37, 2 ... 43
·DIMENSION statement, 1-s,

END,
nseudo•oP, 2w11
statement, 1•27, 1•30
Entry Point, 2•22
ENTRY

Compiler, 1•48, 1•49
t.1ibr~ry,
1-~o, 2•fi7
T.1inkin~l,oader,

SABR,

ranae, 1•25

7.-F,5

2•64

~RROR routine, 2•42
Errors, FOPTRAN, l•47
Executable code, 1•47
Executino the FO?TRAN
proqram, 1•57
Exit, normal, t•25
EXIT subroutine, 1•39, 2•42
EXP functi~n, 1•35, 2•41
fxponentiation, 2•41
Expressions, 1•6, 1•10

Arithri'letic,

1•7

External,
subproqrams, 1•2Q
subrouti~es, 2•1.0
symbnl netinitio~, 2•46
F.xternais, 2•1f,
F"AD,

2•37

Fake indirects, 2•53
rDV,

2•37

F"eatures,
Number•siqn, 2•10
05/8 FORTPAN, 1•1
SARP,

2•1

Field specifications, 1•15
Alphanumeric, 1•15
Numeric, 1 .. 15
fiel~s,

Alphanumeric, 1•t8

Direction ot tlow, 2•19
00 statement, 1•24

2•22

state!T'ent, 1•29
~quivalent symbols, 2·R
Error messages, torl'l'\at, 2•42

1•28, 1•30
OIV, 2•39
DO loops, imPlied,

stat~ment,

F.<WIVALF::Nc:r

1•12, 1•70

MiXed,

1.•21

M1...lmer1c, 1•16
Qeoetition of, 1•21
Sl<ip, 1 •21
First oass, asse~bly,

X-2

2·5~

Generatinq data, 2•17

nx, 2•38

GENIO,

2•43

Fixe.1 oo1nt, 1•2

GOTO

P'liOAT, 2•38

computed, 1•'.?4
unrond1t1o"al, 1•23
Groups,
µepetitinn ot, 1•22

function, 1-v:,
Lihrarv subroutine, 1•43
Floati~q Point arfth~etic,
1•36, 2•37
F' l oat 1 rt q •po 1 I" t. .a cc ti. l'l 1.11 '3 t ~ r ,
i•3h, 2•3'1
FLOT, 2•3A
FMP, 2•37

Format,
f'ECtaoe,
~rror

2•44

~essa~e,

hal'\cil1rH1,

2•42

1•71

stripped ASCII, 1•1H
soecif icati~ns, 1•64
~tatement and, 1•62
FORMAT statement, 1•12,
For~at

1•15

nonexecutable, 1•11
Form~ts,

Multiole record, 1•2?.
F'Of.'TRAN,

RK,

1•1

cnaracter set, 1•2

Handlinq of arqu~ents, 2•21
·r P q u i r e rn e n t 5 ,

H a r d wa r e

F'OCAlJ, 1•1
r.1n1<inll l.oader,

lanquage,

1 •1

np~r~tinq

tnstructlons,

1 •46

usino SARR as oass two,
2·513

FORTRAN Proqram,
executinq the, 1•57
maximum size of a, 1•45
seqmfants, 1•45
FORTRAN statP~ents,
mi x 1 ?"I g SIA B~ an ri , 1 .. 4 4
FORTPAN/SA~R Liorarv
programs, 1 ... 55
FSB, 2•37

Function,- 1.•34
ABS, 1•3S
AV1G, 1•35,

?•41
AUN, 1•35, 2•40

I/O devices, snecial, 1•73
11n list, 1·11.
JARS, 1•3S 2•H
IY,
oseudo•op, 2•14
statement, 1 •24
ffAD,
IFTX,

1•3S, 2•40
1•3'5, 2•41
f'l,QAT, l.•35

TABS, 1•35, 2•39
TFIX,

function, 1•35

rncrementir.q operar.ds, 2•9
1•24, 1-2~
tnitidl value, 1·2~
Tnitializina the system, A•1
Incut/Output, 2•36
statements, t•10
Instruction ~od~s, C•l
tnstructions,
FORTRAN operating, 1•46
Jnrlex,

Multiple wor~, 2•30
Skip, 2•29,
2•33

Inteqer,
arithmetic, 2•39
eonstants, 1•2
variables,

!REM,

SIN,

1•43

Inteqers, 1.•65
Internal suhrouttnes, 2•19
tnH tiibrarv s11broutine,
1•4 2

1 ·~F.

!OPEN,

1 •35
1•35, 2•4('l

SQPT, 1•35, 2•40
TAN,

1•35,

1•4

Library subroutine,

tNTEG~R

1•35

JRf'\SW,

?.•38
?.•38

Impl~mentation "otes, 1•70
1~011e~ DO loops, 1·12, 1-70
IncrP-rnent v~luPs, 1•25

COS,
~~XP,

2•59

SARP, 2•2
Hiqh commo~, 2•49
HollerHh,
constants, 1•3
eonversi(')n, 1•20
strings, 1•37

compiler, ,.•1

errors, 1-47

state~ent,

2·~0

Function ca11s, 1•34
Functions, 2•40
Function Library, 1•35
FUNCTION state~en~, 1•30

2•43

library subroutine, 1•37, 1 •44
IPOWRS Library subroutin~,
1•44

IRDSW, 2•39
tunction, 1•36
I Rfr,i,

2 • 39

fUT"\Ctiori,

JSTO,

X-3

?,•38

1•35

Loaders, A•l
EHN, A•4
PIM,

Label, 2•3, 2•4

LAP oseudo·o~, 2•13
Leader/trailer and checksu~,
,, .;.49

code, 2•45
Library,
erro1'." iressa.gfls, 1-so, 2•67
function.• 1. •35
rroorams, 1 •55
subproqrarns, 1•.34, 2•35
Libr~ry suhroutine,

Leader/tr~iler

ATAN,

1. • 4 4
1•43
1•41

R~JTAPE,

SQRT,

Man1nu1atinq DU~~Y
variables, ?•HI
Maximum size of a FORTPA~
proqram, 1 •45
Mixed fields, 1-21
Mixinq SAHR ~nd FORTRAN
statements, 1•44

1•43

Line contiMUatfoM
desi1riator, 1•8
Linkaqe routines, ?.•30
CDFSKP, 2•31
lHi MS

2•H

trn , 2. • 3 2

Mode,

LlNK, 2•22, 2•32
fiRTSUR, 2•31
OPTSUB, /.•31

routine locations,

2-~o

Link!nq Loader,

1-~s,

'•58

MPY,

2•59

data over the,

/•59

loadinq thP, 1·~6, 2w62
opPration, 2•59 _
relocatahle, 2•20
software requirements,
?.•59

List, 1•1.1
Subscript, 1•5
Literal, used ~s a

parameter, 2•6
Literals, 2•6
Loader reloc~tion co~es,
absolute, 2•45
err current, 2•47
external symbols, 2•46
hiah com~on, 2•4Q
re-oricrir., 2·47
simple re1ocatio~, 2•46
subroutirP. linkd~e, 2•48
transfer vector, 2•4Q

2•39

Mtlltiple,

recorn tor!"'!'3ts, 1-22
word instruction~, 2·30

error messaqps, 2•65
hardware require~ents,
lo~dinq

1•6

Automatic oaqina, 2•29
Numeric conver~ion, 2-~,
'-• t 2
settina, 2-r,

PTN, 2•32
Link~ge

T..1 o a de r ,

the r!M loader, A•3
the SABR assembler, 1·52
Locations,
J !nkaoe routine, 2•60
Peserved, 2•60
Looarith~, natural, 2•41

1 •4·~

rDZSKP,

A.. 1

1•56, ?.·n2

TRTG, 1.•44
UTTLTTY,

tape) I

reloeatable
Proqrams, 1•56, 2•62
the BIN loader, ~-5
t he JJ 1 r'I k 1 n a

'COPEN, 1•44
I P Ol!H~ S ,

c~aoer

Procedures

1 •44

F'l1DAT, 1•43
TNTEGEP, 1•43
TOH, 1•42
POWERS,

A-1

Loadino,
~ binary taoe usina RI~, A•7
and operatinq SAHP, 2·~6
and operatina the
compiler, 1•4f'
data over the
Linkina Lo~der, 2.5q

N•di~ensional

~rrays,

Representation ot, 1•6P
Natur~l loaarithm, 2•41
Nonexecutable FOP~AT
statements, 1.. 11
Norrn~l exit,
t-2~
Nllll

lin~s,

2•4

Number•siqn feature, 2•10
Numbers,

real, 1 •66
tntPqer, 1•65
Numer1C'.',

characters, 2•2
coT"!stants, 2•5
C"'.OT'\VPrsi~n

mode,

2•12
field codes, 1•1~
field specifications, 1•15
Input corver~ion, 1•17
2•6,

X-4

OBTSUB Linkaqe routi~e,
2·31
OCLOSE subroutine, 1•38, 2•43
OCTAL pseu~o-oo, 2•5, 2•6,

Pseudo•oPerators, 2•10, C•],
AASYM, 2•15
ARG,

CAl·I.11 2•21

2 .. 12
OOPEN subroutine,

1 •3A,

Storage map, 1•57 ,. 2•61

switch register, 2•60
Origin, relative, 2•45
05/8 FORTRAN,
features, 1 •1
Library subroutines, 1•42
OS/B USR and device
handlers, 2•56
Output tapP., binary, 2•45
Overt low, 1•36
Packed six•bit ASCII text
strings, 2•19
Paqe,
eseapes, 2•21, 2•29
format, 2•29
PAGE pseudo•op, 2~13, 2•53
Paqe•bY•Paqe assemblv, 2-2~
Paqing mode, automatic, 2•2q
Parameters, 2~s, 2•7
Parentheses~ 1•6
Passing subrouti"e
arguments, 2•24
PAUSE,
pseudo•op, 2•11

statement, t•26
Permanent symbol table,
SABH, C•t

Permanent symbols, 2•7
POWER routines, ?•41
POWE~S Library suhrcuttne,
1•43

Procedures (paner taoe),
J.,011HHnq,

A•1

COMMN, 2•16
Conditiona1, 2•14

2•43

OPDfF pseudo•oP, 2•15
Oper~nds, , .. 3, 2•5
addrPsses, 2•5
tnerPmentinq, 2•9
Operatinq,
characteristics (SAR~), 2•28
instructions CFOPTPAN), 1•46
the Linkinq Loader, 2•59
the SARR assembler, 1•52, 2"'56
Operations, alqebraic, 1•6
Operatnr, 2•3, 2•4
OPJSUR-Linkaqe routine,
2•31
Optimizing SABR code, 2•53
Options,
_r.ore availab!l!ty, 1•57, 2"'61

2•?.1.

BL1'1CJ<, 2•17

CPAGr:, 2 .. 13
PE:ClM, 2•5, 2•6, 2•12
DUMMY,

F:AP,
ENO,

2•24

2•13
2•11

Tf, 2•14
l·AP, 2 .. 13
OCTAL, 2•5,

2•6,

2•1.2

npot:F, 2•15
PAGE, 2•13, 2•53

PAUSE, 2•11
REORG, 2• 13

SKPDF, 2•15, 2•33

n:xr, 2-1 s

Range,
integer consta~ts, 1•3
inteaer variables, 1•4real constants, t-3
Re•or!q!n, 2 ... 47
READ,

2•36

statement, 1-11, 1•13
Real constants, 1•3
nu~bers,
1•6n
variables, 1•4

Record torma~s, multiple, 1•22
Records, 1•12
Relative o~igin, 2•45
Retocatable,
binary orograM tapes, 1•55
11nk1nq loader, 2-20
Program toan1nq, 1•56, 2•62
REORG pseudo•oP, 2•13
Repetition,
of fields,

1•21

of qroups, 1•22

Replacement operator, t-10
Rel"'resentat!on.
of constants and variables, 1•65
ot n•dimensional arrays, l•bA
Reserved locations, 2•60
Reservinq words of cnre, 2•17
Restarting SABR, 1•54 ·
RETRN,

2•22

RETURN,
key, 2•3

staterrent, 1w3t'), 1 .. 34
RIM loadPr proqr~ms, A•2
Routine,
DECtape T/O, l•H

DUMMY, 2•24

Program addresses, 2•34
Proqrammino hotes,

FRROR 1 2•42
LINK, 2•22

SABH, 2•53

Pawn~,

X-5

2•41

RTAPE,

HTN,

StaterH~nt,

1""3~

and format soecif!cations, 1•62

2•37

WT~.PE,

CAIJL, 1•33
CAT.1L UPEN, 1.•27

1-39

tJtil!tv, 2·41

COMMON,

Rules for user•detined
2•30

RWTAPE Library subroutine,
t .. 44

FNTRY,

2•2R,

ti.P.lr1r

1•29

1•8

FORMAT, 1•12, 1•15
FUNCTION,

r.oro, 1-23
Tf,

2•56

\•30

1•24

11-ne, 2•3

Permanent _symbol table, C•1
proqrammino notes, 2•53
restarting, 1•54

number, 1 •A
PAtJSF:, 1•2n

system conf iquration, 2·2

PEAD, 1•11, 1 .. 13
RETFHJ, 2•22

SARP and FOPTRAN statements,
mixing, 1•44
SABR as FORTRAN CdSS two, 2-~e~
SA~R assemt"ler,
loadinq the, 1•52
operatinq the, 1•52
SABR code, oPtimizinn, 2•53
~ample assembly listings, 2•4Q
Scal~r variables, 1-4
Second pass, assembly, 2-~o
Set CSAHR), character, 2-2
Setting; morle, 2•5
Simple relocatio~, 2•46
SIN tunction,

t-3~,

2•29, 2•33

SKPDf pseudo•on, 2•15,
s1asn, 1-22

Software

~TOP,

1•?.7

:=;UBROUTINE,

2•33

require~ents,

Lirtl<inq J,oarler,

, ... r;g

Source proqram, 1•1, 1•52
Source tape, 1•47
Special char~cters, 2•2
Special I/O devices, 1·73
Sppc1.fication statements,
, •"7

1•32

tyr>es, 1•9
WPITF,

1•1 l, 1•14

Statements, 1•R, 2•3
Arithmetic, 1•10
Control,

1•23

nata transmission, 1-11, 1-1s
Input/Outnut, 1~10
mixirHJ SARR anrl

STO,

2•37

2•J b

conservina space, 1•29
lo~ation,
1•29
maii option, t•57, 2•61
ot array::-, 1•67
Storaqe and constants,
variable, 1·47
Strinqs, Kollerith, 1·17
StriPPed ASCJI tormat, 1•1A
Su~orooram,

library, 2·35
statements, 1•29

fiubproorarns,
External, '•29
vunction, 1•.30

SQRT,
function, 1•35, 2•40
Lihrarv subroutine, t•44
Stdndards,

Suhroutine,

F 0 RT RA r~ ,

·1·44

STOP statement, 1•27
Storaqe,
alloc~tion,
1•65

Speci.fications,
Formot, f•64
Statement, 1 •62

ANS l

f"URTR~_M,

nonexecutable FORMAT, 1•11
Specification, 1•27
Suhprociram, 1•29

comrnon,

l•21

lnstru~tion,

1•30, 1•34

RETURN,

2·40

SiX•bit ASCII text strin0s,
packed, 2•1.R
Size of a FORTRAN Program,
maximum, 1•45
Skip,
fi~lds,

1•30

;, .. 22·

f:(~UIVALENCE,

SARR,
asem.bler, 2•1
assemblies, t•5S
error messages, 2•64
features, 2•1
op~rating,

1•28

C:ONTINl.JE, 1 •2b
DIMENSTON, 1•5, 1•2A,
DO, 1•24
Dummy, 1•26
ENfl, 1•27, t•30

svrnbols, 2•8
Run•Time Linkage koutin~s,

T,ibrnry, 1•34
~ ti h r o ll t 1 n e ,
t .. 3 1
arqu~ent

passinq, 2·24

CHAIN, 1•34
C ti~ i n 1 f'I q t n

1• n7

X-6

a, 1 - ·Hi

r.nn,

Table, SARR permanent 5Ymbol,

7.•42

2•34,
Tabs, t•9

EXIT, 1•39, 211142
TOPEN,

1""37

TAN function,

li~kage code, 2•48
nct_,nsE, 1·38

'10PEN 1

l ... 39

SUBROUTINE state~ent, 1•32
Subroutines,
Closed, 1•29

ASCJT,

Two's

Subscript list, 1•5
subscripted variables, 1-s, 2•39
Subscriptinq, 1•5, 2•39
Suhscripts, array, 1•28
Subscripts of arravs,
Calculatinq, \•~A
Suppress inn.,
assembler output, 1•53
c C"'11, p i 1 e r o u t ::: ;J t , 1 • 4 7
switrh reqister option~,

Unconditiorial GOTO,
Underflow, 1•36
Up arrow, 1-4A

User•det1nen symbols, 2•8
Rules tor, 2•8

Usina SABR as FORTRAN pass

UTILITY Library subroutine,

2-1~

1·43

C•1
Sym~ol taole tJaas, 2•34
Symhnlic ianauaqe CSABR),

Utility routines, 2•41

Variables, 1•3, 1•10, 1•25
Array,

fivmbnl1c machine lanquage
~~

rr
~"

m t~p~, 1•52

IT!axirnum, 1•18
2 ... p

Real,

n~~r,,... riefined,

A•1

2~2

FO?TFIAN,

System

i•R

Tniti~lization,

1•4

Representation ot
const"T"lts and, 1·65
scalar, 1 ... 4
~uhscripted, 1•5, 2•19

r>erf:'anP.nt, 2""°1
~SA~P,

1-s

Integer, 1 •4
maniPUldtinq DUMMY, 2-10

2,,.7

Fqt]iValent,

SystPm

1•23

two, 2•59

def tn1tio~,
ta~1e, 2•34
p~rm~nent,

~y"'fb'"'

binary,

Two•rlimensional arrays, 1•~R
Two•word block, 2•22, 2·~4
Two-word vector, 2•32

2 ... fiO

SAR

co~Plement

1•65

2•39

sym~o

2•1R

Transter VP.ctor, 2•49
TRIG Library suhrootinP.,
Truncation, 1•4

OS/B FOPTRAN Library, 1•42

sy~b~l

2•40

1•44

2•?0

IntP.rnal, ?.•19
SUBSC,

1·3~,

value, 1•25
TEXT pseudo-~p, 2•1A
Text str!nos, oacked six•bit
Ter~inal

subproorams, 1•31

Fxtern~l,

c-1

1•1

d~vice,

1•46

WRITE,

2•36

WRT.TF. statPment, 1•11, 1•14
WTAPE routine, 1•39, 2•43

X-7

HOW TO OBTAIN SOFTWARE INFORMATION
SOFTWARE NEWSLETTERS, MAILING LIST
The Software Communications Group, located at corporate headquarters in
Maynard, publishes newsletters and Software Performance Summaries (SPS)
for the various Digital products. Newsletters are published monthly,
and contain announcements of new and revised software, programming
notes, software problems and solutions, and documentation corrections.
Software Performance Summaries are a collection of existing problems
and solutions for a given software system, and are published periodically. For information on the distribution of these documents and how
to get on the software newsletter mailing list, write to:
Software Communications
P. 0. Box F
Maynard, Massachusetts 01754
SOFTWARE PROBLEMS
Questions or problems relating to Digital's software should be reported
to a Software Support Specialist. A specialist is located in each
Digital Sales.Office in the United States. In Europe, soft\'fare problem
reporting centers are in the following cities.
Reading, England
Paris, France
The Hague, Holland
Tel Aviv, Israel

Milan, ltaly
Solna, Sweden
Geneva, Switzerland
Munich, West Germany

Software Problem Report (SPR) forms are available from the.specialists
or from the Software Distribution Centers cited below.
PROGRAMS AND MANUALS
Software and manuals should be ordered by title and order number.
In
the United States, send orders to the nearest distribution center.
Digital Equipment Corpo~ation
Software Distribution Center
146 Main Street
Maynard, Massachusetts 01754

Digital Equipment Corporation
Software Distribution Center
1400 Terra Bella
Mountain View, California 94043

Outside of the United States, orders should be directed to the nearest
Digital Field SalesrOffice or representative.
USERS SOCIETY
DECUS, Digital Equipment Computer Users Society, maintains a user exchange center for user-written programs and technical application information. A catalog of existing programs is available. ·~he society
publishes a periodical, DECUSCOPE, and holds technical seminars in the
United States, Can?tda, Europe, and Australia. For information on the
society and membership application forms, write to:
DECUS
Digital Equipment Corporation
146 Main Street
Maynard, Massachusetts 01754

DEC US
Digital Equipment, S.A.
81 Route de l'Ai~e
1211 Geneva 26
Switzerland

BK FORTRAN SABR ASSEMBLER

READER I s COMMENT S
0

NOTE:

DEC-8-LFTNA-A-D

This form is for document comments only. Problems
with software should be reported on a Software
Problem Repcrt (SPR) form (see ~he HOW TO OBTAIN
SOFTWARE INFORMATION page) .

Did you find errors in this manual?

If so, specify by page.

Did you find this manual understandable, usable, and well-organized?
Please make suggestions for improvement.

Is there sufficient documentation on associated system programs
required for use of the software described in this manual? If not,
what material is missing and where should it be placed?

Please indicate the type of user/reader that you most nearly represent.

Assembly language programmer

0
0

Higher-level language programmer

0
0
0

Occasional programmer (experienced)
User with little programming experience
Student programmer
Non-programmer interested in computer concepts and capabilities

Name
Org~nization

Date------------_____________________________________________

Street ____________________________________________
City ________________________

~State

_________,,_ _ zip Code _ _ _ _ _ _ __
or
Country

If you do not require a written reply, please check here.

[]

·--~---------------------------------------------------------Fold llere------------------------------------------------------------

·----------------------------.. ------------------ Do Not Tear · Fold llere and Staple -----------------------------------------------

FIRST CLASS
PERMIT NO. 33
MAYNARD. MASS.
BUSINESS REPLY MAIL
NO POSTAGE STAMP NECES5ARY IF MAILED IN THE UNITED STATES

Postage will be paid by:

. Software Communications
P. · O. Box F

Maynard, Massachusetts

01754

,..,

~-~':''

...