Digital PDFs

DEC-S8-LFSSA-A-D

June 1973

112 pages

Original

3.8MB

Document:	OS8 Fortran IV Software Support Manual 197306
Order Number:	DEC-S8-LFSSA-A-D
Revision:
Pages:	112
Original Filename:	http://bitsavers.org/pdf/dec/pdp8/fortran/DEC-S8-LFSSA-A-D_OS8_Fortran_IV_Software_Support_Manual_197306.pdf

OCR Text

so~ware

support manual

digital equipment corporation

DEC-S8-LFSSA-A-D

OS/8 FORTRAN IV

SOFTWARE SUPPORT ~ANUAL

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

digital equipment corporation · maynard. massachusetts

First Printing
June, 1973

@) 1973 by Digital Equipment Corporation

The following are trademarks of Digital Equipment Corporation,
Maynard, Massachusetts:
CDP
COMPUTER LAB
COMTEX
COMSYST
DDT
DEC
DECCOMM
DECTAPE
DIBOL

4/81·16

DIGITAL
DNC
EDGRIN
EDUSYSTEM
FLIP CHIP
FOCAL
GLC-8
IDAC
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

CONTENTS

CHAPTER 1

THE F4 COMPILER

1=1

CHAPTER 2

THE RALF ASSEMBLER

2-1

CHAPTER 3

THE FORTRAN IV LOADER

3-1

CHAPTER 4

THE FORTRAN IV RUN-TIME SYSTEM

4-1

CF..APTER 5

LIBRA AND FORLIB

5-1

APPENDIX A RALF Assembler Permanent Symbol Table

A-I

APPENDIX B Assembly Instructions

B-1

iii

CHAPTER 1
THE F4 COMPILER
The OS/8 F4 compiler runs in 8K on either a PDP-8 or a PDP-12.

It op-

erates in three passes to transform FORTRAN IV source programs into
RALF assembly language.
1.

The function of each of the three passes is:

Analyze statements, check syntax and convert to a polish
notation.

Convert output of PASSl to RALF assembly language making ex=
tensive use of code skeleton tables.

Produce a listing of the FORTRAN source program and/or chain
to the assembler.

The following is a more complete description of each of the three
passes.

PASSI OPERATION
After opening the source language input file(s) and an intermediate
output file, PASSl processes statements in the following fashion:
1.

Assemble a statement into the statement buffer by reading
characters from the OS/8 input file.

This section eliminates

comments and handles continuations so that the statement
buffer contains the entire statement as if it had been written
on one long line.
2.

The statement is first assumed to be an arithmetic assignment
and an attempt is made to compile it as such.

This is done

with a special switch (NOCODE) set so that in the event the
statement is not arithmetic, no erroneous output is produced.
Thus, with this switch set, the expression analyzer subroutine
is used merely as a syntax checker.
3.

If the statement is indeed an arithmetic assignment statement

(or arithrrtetic statement ftL."1.ction) the sWTi tch is set off and
the statement is then recompiled, this time producing output.

1-1

If not an arithmetic assignment, the statement might be one
of the keyword defined statements.

The compiler now checks

the first symbol on the line to see of it is a legal keyword
(REAL, GOTO, etc.) and jumps to the appropriate subroutine if
so. Any statement that is not now classified is considered to
be in error.
5.

The compilation of each statement takes place.

Some state-

ments produce only symbol table entries (e.g., DIMENSION)
which will be processed by PASS2.

Others use the arithmetic

expression analyzer (EXPR) and also output special purpose
operators which will tell PASS2 what to do with the value
represented by the arithmetic expression (e.g., IF, DO).
6.

After the statement has been processed, control passes to the
end-of-statement routine which handles DO-loop terminations
and then outputs the end-of-statement code.

Statements containing some kind of error cause a special
error code to be output.

The entire process is now repeated for the next statement.

When the END statement is encountered, PASSI chains to PASS2.

PASSI SYMBOL TABLE
A significant portion of the PASSI processing involves the production
of symbol table entries.

These entries contain all storage related

information, i.e., variable name, type, dimensions, etc.

The symbol table is organized as a set of linked lists.

The first 26

such lists are for variables, with the first letter of the variable
name corresponding to the ordinal number of the list.

There are also

separate lists for statement numbers and literals (integer, real,
complex, double, and Hollerith).

In addition to list elements, there

are special entries for holding DIMENSION and EQUIVALENCE information.

1-2

A detailed description of each type of entry follows.

(NOTE:

All

symbol table entries are in Field 1.)
1.

VARIABLE - The first word of each entry is a pointer to the
next entry, with a zero pointer signaling end of list.
second word contains type information.

The

The third word points

to the dimension and/or equivalence information blocks.

The

next one to three words contain the remainder of the name
(the first character is implied by which list the entry is in)
in stripped six-bit ASCII terminated by a zero character.
Thus, shorter variables take less symbol table space.

The

entries are (as for all lists in the symbol table) arranged
in order of increasing magnitude, or alphabetically.

POINTER
TYPE

mrrm
...

DIMENSION/EQUIVALENCE
NAME 2-3
NAME 4-5

NAME 6

TYPE WORD FORMAT
0

COM

2
M

lEx T

3
AS

IEQ
I

U
I
V

L~
J.

I
C

II E II

BIT
~

Variable is in common.

Variable is dimensioned.
External symbol or subroutine/function name.
Symbol is the name of an arithmetic statement function.

3
5

Variable is an equivalence slave.
Variable is explicitly

Entry is a literal.

Variable is a formal parameter.

1-3

1
2
3
4
5
8
9

8-11
Type

integer
real
complex
double
logical
statement number
common section name

STATEMENT NUMBER - The first two words are the standard
pointer/type.

The next three words are the statement number,

with leading zeros deleted, in stripped six-bit ASCII, filled
to the right with blanks.
POINTER
TYPE
NUMBER 1-2
NUMBER 3-4
NUMBER 5
3.

INTEGER OR REAL LITERALS - The first two words are the pointer
and type.

The next three words are the value in standard

floating-point format (12-bit exponent, 24-bit signed 2's
complement mantissa).

Since the type of the literal must be

preserved, there are two lists; hence use of 1 and

l.~

in the

saroe program will cause one entry in each of the integer and
real literal lists.
POINTER

TYPE
EXPONENT
MANTISSA 0-11
MANTISSA 12-23
4.

__
LU
E

COMPLEX LITERALS - The first two words are standard.

The

next three are the real part in standard floating-point
format.

The next three are the imaginary part.

1-4

~
~L~

POINTER
TYPE
REAL EXPONENT

REAL MANTISSA 0-11
REAL

M&~TISSA

12-23

IMAGINARY EXPONENT
IMAGINARY MANTISSA

O-ll~

IMAGINARY MANTISSA 12-23
5.

DOUBLE PRECISION LITERALS - The first two words are standard.
The next six are the literal in FPP extended format (72-bit
exponent, 60-bit mantissa) •

•

POINTER

Jj tIll

TYPE
EXPONENT
MANTISSA 0-11
rJ..ANTISSA 12-23
MANTISSA 24-35
MANTISSA 36-47
MANTISSA 48-59
6.

HOLLERITH (quoted) LITERALS - The first two words are standard.

The next N words are the characters of the literal in

stripped six-bit ASCII, ending in a zero character.
POINTER
TYPE
CHARACTERS 1-2
etc.
7.

DIMENSION INFORMATION BLOCK - If a variable is DIMENSIONed,
the third word of its symbol table entry will point to its
dimension information block (may be indirectly, see section
8 below).
dimensions.

The first word of this block is the number of
The second word is the total size of the array

in elements; thus the size in PDP-8 words may be 3 or 6 times

1-5

this number.

The third word contains the "magic number"

which is computed as follows:
n-l
MN= - 1+ L
i=l

j=l

where d. is the jth dimension and n is the number of
J

dimensions.
For a 3-dimensional variable this number becomes:

The magic number must be subtracted from any computed index,
since indexing starts at one and not zero.

The fourth word

will (in PASS2) contain the displacement from #LIT of a
literal which will contain either the magic number in
un-normalized form (for dimensioned variables which are
subroutine arguments) or the address of the variable minus
the magic number (for local or COMMON dimensioned variables) .
This literal is necessary for calling subroutines where a
subscripted variable is an argument.
the dimensions of the variable.

The next N words are

If the variable is a formal

parameter of the subroutine, it may have one or more dimensions which are also formal parameters.

In this case, the

magic number is zero, and the dimension(s) is a pointer to
the symbol table entry for the variable(s) used as a dimension.
NUMBER OF DIMENSIONS

TOTAL NUMBER OF ELEMENTS

SIZE

MAGIC NUMBER

RESERVED
DIMENSION 1

DIMENSION 2

DIMENSION n

1-6

EQUIVALENCE

INFO&~TION

BLOCK - If a variable is an

EQUIVALENCE slave variable, the third word of its symbol
table entry points to the equivalence information block.
The first word of this block points to the dimension information (if any) of the

variable~

The second word points to

the symbol table entry of the EQUIVALENCE master variable.
The third word is the linearized subscript of the master
variable from the

EQUIV~LENCE

statement;

the linearized subscript of the

s~ave

The fourth word is

variable.

POINTER TO DIMENSIONS
POINTER TO MASTER

CO~~~ON

MASTER SUBSCRIPT

SSM

SLAVE SUBSCRIPT

SSM

INFOP~~~TION

BLOCK - If a symbol is defined as the nwue

of a COMMON section, the third word of its symbol table entry
points to a list of common information blocks.

The first

word of each such block points to the next block.

The second

word is the number of entries in the list that follows.

The

rest of the block is a set of pointers to the symbol table
entries of the variables in the COMMON section.
POINTER TO NEXT CIB
NmvffiER OF ENTRIES
POINTER TO VARIABLES
IN THIS COMMON

{

~____.
__
.~

PASSl OUTPUT
The output of PASSl is a stream of polish with many special operators.
Whenever an operand is to be output, the address of its symbol table

entry is used.

The following is a list of the output codes (in their

mnemonic form, obtain numeric values from listing of PASS1) and the
operation they are conveying to PASS2:

1-7

PUSH

The next word in the output file is an operand
(symbol table pointer) to be put onto the stack.

ADD

Add the operands represented by the top two stack
entries (actually this causes PASS2 to generate
the RALF coding which will do the desired add).

SUB

Subtract top from next-to-top.

MUL

Multiply top two.

DIV

Divide top into next-to-top.

EXP

Raise next-to-top to power of top.

NOT

Logical .NOT. of top of stack.

NEG

Negate top of stack.

Compare top two for greater than or equal to, this
has TRUE value if the next-to-top is .GE. the top.

Compare for greater than.

Compare for less than or equal.

Compare for less than.

AND

Logical AND of top two entries.

Logical inclusive OR of top two.

Compare top two for equality.

Compare top two for inequality.

XOR

Exclusive OR of top two.

EQV

EQUIVALENCE of top two.

PAUSOP

Use top of stack as PAUSE number.

DPUSH

The next two words are a symbol table pointer and
a displacement; put them onto the stack (used for
DATA statements) .

BINRDl

Take the top of stack as the unit number and compile an unformatted READ-open.

FMTRDl

The top two stack elemeLts are the unit and format,
take them and compile a formatted READ-open.

1-8

RCLOSE

Compile a READ-close.

DARDI

Take the top two stack elements as a unit number
and a block number and compile a direct access
unformatted READ-open.

BINWRI
FMTWRI
WCLOSE
DAWRI

Same as for the corresponding READ case, except
substitute the word "WRITE".

DEFFIL

Take the top four stack entries as the unit,
number of records, record size, and index
variable and compile a DEFINE FILE call.

ASFDEF

Set the PASS2 switch which says that the following
statement is an arithmetic statement function.

ARGSOP

The next word is a count, call it n; take the
previous n stack entri~~ as subscripts (or
arguments) and the N+l
entry from the top as
the array (or function) name; now compile this
as an array reference (or function/subroutine call).

EOLCOD

The current statement is completed, reset stacks
and do other housekeeping.

ERRCOD

The following word contains an error code, write
it on the TTY together with the current line
number, and put the error code and line number
into the error list for possible PASS3.

RETOPR

Compile a subroutine RETURN.

REWOPR

Take the top of stack as a unit and compile a
re",ind~

STOROP

Compile a store of the top of stack into the
next-to-top.

ENDOPR

Compile a P~TURN if a function or subroutine or
a CALL EXIT if a main program.

DEFLBL

The following word is a symbol table pointer to
a statement number, compile this as the tag for
the current RALF line.

DOFINI

The following word is a symbol table pointer for
the DO-loop index, compile the corresponding
DO-ending code.

~.RTHIF

The following one, two, or three words are symbol
table pointers to statement numbers for the less
than zero, zero, and greater than zero conditions
with the comparison to be made on the top of
stack.

LIFBGN

The top of stack is taken as a logical expression
PASS 2 should compile a jump-around-on-falsei this
implies that some statement is to follow.

1-9

DOBEGN

The top two stack entries represent the final
value and increment of the DO-loop, process them
in hopes pf finding a matching DOFINI.

END FOP

The top of stack is a unit, compile an END FILE.

STOPOP

Compile a CALL EXIT.

ASNOPR

The next word is the address of the symbol table
entry for a statement number; compile an ASSIGN
of this statement number to the variable represented
by the top of stack.

BAKOPR

Take the top of stack as the unit and compile
a BACKSPACE.

FMTOPR

The following word is a count Ni the next N words
after that are the image of the FORMAT statement.

G020PR

The following word is the symbol table entry for
the statement number which is to be executed next.

CG020P

The following word is a count Ni the next N words
are symbol table pointers for the statement
numbers of a computed GO TO list; use the value
represented by the top of stack to compile a
computed GO TO into this list.

AG020P

Compile an assigned GO TO with the top of stack.

IOLMNT

Take the top of stack as a list element for an
I/O statement and compile read or write; PASS2
knows if it is a READ or WRITE by remembering
previous FMTRDl, FMTWRl, etc.

DATELM

The next word is a count Ni the next N words are
a data element.

DREPTC

The next word is a repetition count for the set
of DATELMs up until the next ENDELM.

ENDELM

Signals the end of a data element group.

PRGSTK

Tells PASS2 to purge the top stack entry.

DOSTOR

Performs the same function as STOROP after
checking the top two stack elements for legal
DO-parameter type (integer or real).

PASS 1 SUBROUTINES
The following is a brief description of the function-of each of the
major PASSl subroutines:
RDWR

Compiles everything in a READ or WRITE statement
starting at the first left parenthesis.

1-10

RESTCP

Restore character pointer and count for the
statement buffer from the stack.

OUTWRD

Output a word (the AC on entering) to the PASSl
output file.

COMARP

Test for comma or right parenthesis; skip one
instruction if a comma, two if a right parenthesis,
and none if neither.

BACKl

Backup the statement buffer character

GETSS

Scans a variable reference, or subscripted variable
reference with numeric subscripts and returns the
linearized subscript.

MUL12

Perform a l2-bit unsigned integer multiply.

DOSTUF

Handles compilation of DO-loop setup.

TYPLST

Process a type declaration, DIMENSION, or
COMMON statement; sets up type bits and/or
dimension information.

LOOKUP

Perform a symbol table search for variables and
Hollerith literals.

LUKUP2

Perform a symbol table search for integer, real,
complex, and double precision literals or
statement numbers.

EXPR

Analyze and process an arithmetic expression.

LETTER

Get next character from the statement buffer and
skip if it is a letter, otherwise put the
character back and don't skip.

CHECKC

The first word after the JMS is the negative of
the ASCII character to test for; if this is the
next character, skip.

GETCWB

Get the next character from the statement buffer
preserving blanks.

SAVECP

Save the character pointer and count on the
stack.

GETC

Get the next character ignoring blanks.

ERMSG

Output an error code to PASSl output file.

POP

Pop the stack into the AC.

PUSH

Push the AC onto the stack.

LEXPR

Analyze and process an arithmetic expression,
legal to the left of the equal sign in an
assignment statement.

GET2C

Get the next two character into one word.

1-11

pointer.

STMNUM

Scan OII a statement number and do the symbol
table search.

DIGIT

Same as letter, except checks for a digit.

NUMBER

Scans off an integer, real, or double precision
literal.

GETNAM

Scan off a variable name.

ICHAR

Get the next character from the input file.

PASS2 OPERATION
The first part of PASS2 generates the storage for variables, arguments,
arrays, literals and temporaries by processing the symbol table
built by PASSl, which is kept in core.

The next step is to generate

the code for subroutine entry and exit including argument pickup and
restore.

After all such prolog code is generated, PASS20 is loaded

into core, overlaying most of the prolog-generating functions.
main loop of the compiler is now entered.

The

This consists simply of

reading a PASSI output code from the intermediate file and using this
number as an index into a jump table.

The sections of code entered

in this way then perform the correct generation of
Example:
The statement: A=B+C*D
would produce the following PASSl output:
(assuming A,B,C,D are REAL)

PUSH
+A

(symbol table address of A)

PUSH
+B

PUSH
+C

PUSH
+D

MUL

ADD

STOROP

EOLeOD
1-12

P~LF

code.

The corresponding operations performed by PASS2 are:
1)

Make a 3-word entry on the stack corresponding to the
variable A consisting of a pointer to the symbol table
entry, a word containing the type, and one reserved word.

Repeat above for B.

Repeat above for C.

Repeat above for D.

The multiply operator is handled like any of the binary
operators by the subroutine CODE. This routine is called
with the address of the multiply skeleton table. The
top two stack entries are taken as the operands, with
their types used to index into the skeleton tables.
(See description of binary operator skeleton tables below.)
The correct skeleton for this combination is chosen based on
the where-abouts of each of the operands (AC or memory)
at the corresponding point in the code which is being
compiled. There are three possible cases: Memory ,AC ;
Memory ,Memory i AC,Memory.
In this example, both operands
are in memory so the code generated would be:
FLDA C
FMUL D
The CODE subroutine then makes a new stack entry to replace
the entries for C and D. This entry has a ~ in place of
the symbol table pointer, signifying that the operand is in
the AC. Other special case operand codes are:
~

AC ( Already mentioned)

1 - 51 Temporaries
52 -

Array reference, the subscript of which is in
an index register (1-7).

61 - A variable, the address of which is in base
location ~.
62 - A variable, the address of which is in base
location 3.
63-6777 - Symbol table entry (can be variable or literal).
7000 - Special temporary
6)

The add operator is handled in the same way as for multiply,
except that in this case the add skeleton table is used.
When the correct row is found, the memory,AC case is chosen
since the result of C*D is now in the AC. This skeleton
simply generates:
FADD B
The new top of stack entry is a
the AC.

since the result is in

The store operation works in a similar manner using a special
skeleton table to determine whether the value to be stored is

1-13

already in the AC and whether it must be converted from one
type to another. In this case, no conversion need be performed
and the code generated is:
FSTA A
8)

The end of statement has been reached and any necessary
bookkeeping is performed.

PASS2 SYMBOL TABLE
PASS2 modifies the symbol table entries corresponding to variables
by replacing the first word of the entry with the first character of
the name, this character being derived from the list in which the name
is located.

PASS2 ERROR LIST
PASS2 creates a list (in field 1) of error codes and line numbers
corresponding to the errors printed on the Teletype during PASS2.
This list works downward starting just below the skeleton table area,
working towards the symbol table area.

PASS3 uses this list to

write out extended error messages on the listing.

PASS2 SKELETON TABLES
All binary operators have associated with them a skeleton table
having 24 entries arranged in 8 rows and 3 columns.

The rows

correspond to the following eight possibilities:
I}

Both operands integer or real.

Both operands complex.

Both operands double precision.

First operand integer or real, second complex.

First operand integer or real, second double precision.

First operand complex, second integer or real.

First operand double precision, second integer or real.

Both operands logical.

1-14

The columns correspond to the following three possibilities:
l}

First operand in memory, second in AC.

Both operands in memory.

First operand in the AC, second in memory.

Each entry of the skeleton tables is either zero (illegal operatortype combination) or points to a code skeleton (minus one).

Code

skeletons are composed of combinations of the following types of
elements:
l}

OPCODES - If an element has a non-negative value, it is
taken as the address of a text string for the desired
opcode. This works since all such text strings are
stored below location 4~~~ (in field ~). In this case,
the next word of the skeleton is taken as a designator
for the address field, the possibilities are:
a.

A non-negative values means the address field is a
literal text string, with the value being the address of the string.
(Same restriction as for opcode text strings.)

A zero indicates that this instruction should have
no address field.

A minus one indicates that the address field is the
operand defined by the three variables ARG1, TYPE1,
and BASEl.

A minus two indicates that the address field is the
operand defined by the three variables ARG2, TYPE2,
and BASE2.

MODE CHANGE - An element value of minus one means generate
a STARTF if currently in extended mode. A value of
minus two means generate a STARTE if currently in single
mode.

MACRO - Any other negative value is taken as the address
(minus 3) of a sub-skeleton. This sub-skeleton may
contain anything except another sub-skeleton reference.
When the end of the sub-skeleton is encountered, the main
skeleton is re-entered.

END-OF-SKELETON - A zero indicates the end of the skeleton.

PASS2 SUBROUTINES
The following is a list of the major PASS 2 subroutines together
with a brief functional description.

1-15

ERMSG

Output a 2-character error code together with the
line number on the Teletype~ also put the code and
line number into the error list for PASS3.

UCODE

Generate the code for unary operators, given the
skeleton table address.

CODE

Generate code for binary operators, given the
skeleton table address.

INWORD

Read a word from the PASSI output file.

FATAL

Output a fatal error message and exit to OS/8.

ONUMBER

Output the AC as a 4-digit octal number.

SAVEAC

Generate an FSTA #TMP+XXXX if necessary.

GENCOD

Generate the code specified by the given code
skeleton.

OPCOD

Output a TAB followed by the specified opcode
field.

OPCODE

Same as OPCOD, except output a second TAB after the
opcode field.

OADDR

Generate the address field specified by the
argument.

GENSTF

Generate STARTF if in E mode.

GENSTE

Generate STARTE if in F mode.

OSNUM

Output a statement number preceded by a If#".

CRLF

Output a carriage return/line feed.

OTAB

Output a TAB.

OUTSYM

Output a text string.

GARG

Pop the top entry of the stack into ARGl, TYPEl,
and BASEl.

GARGS

Pop the top two stack entries into ARGl, TYPEl,
BASEl and ARG2, TYPE2, BASE2.

OUTNAM

Output a variable name.

OLABEL

Output a generated label.

GETSS

Find the address of the dimension information
block given the symbol table address.

SKPIRL

Skip if integer, real, or logical.

GENCAL

Generate the code for a subroutine call from
the information contained on the stack.

MUL12

Do a l2-bit unsigned multiply.

1-16

OINS

Output a literal opcode and address field.

OCHAR

Output a character

NUMBRO

Output a 5-digit octal number.

PASS3 OPERATION
PASS3 first initializes the listing header line with the version
number, date, and page number.

It then processes lines, much like

PASS1, handling continuations and comments and outputs their image
to the listing file together with the line number.

A constant check

is made on the error message list for line numbers that correspond
to the current line number,

~~en

such a correspondence occurs, the

error code is used to find the associated detailed error message,
which is then printed out.

1-17

CHAPTER 2

THE RALF ASSEMBLER
RALF and FLAP are essentially the same program, with differences controlled by the conditional assembly parameter RALF, which must be nonzero to assemble RALF, or zero to assemble FLAP.

The source may be

assembled by either PAL8 or FLAP; although FLAP flags one error (a US
on a FIELD statement) i this may safely be ignored.
this chapter applies to RALF only.

The remainder of

The following definitions are pre-

requisite to discussion of the operation of this assemblero
MODULE

The relocatable binary output of an assembly. A module
is physically an OS/8 file or sub-file in a library;
and is made up of an external symbol dictionary and
related text.
Logically, it consists of one or more
program sections and COMMON sections.

LIBRARY

An OS/8 file on a directory device containing a catalog
and one or more modules as sub-files.
Used solely by
the loader, as a source of modules with which to satisfy
unresolved symbols in a program being loaded.

CATALOG

A list of entry points defined in modules contained in
a library, with an indication of the locations of the
modules which define them.

EXTERNAL
SYMBOL
DICTIONARY

A list of the global symbols defined in and/or used by
a module. Usually called ESD table.

TEXT

That part of the assembler's binary output which contains
the binary data to be loaded into memory, along with
sufficient information for the loader to associate the
output with specific memory locations through references
to the ESD table.

SECTION

A unit of binary data output by the assembler as part
of a module to be loaded into a contiguous area of
memory.
COMMON sections are a special case in that
they may be defined with the same name in each of many
modules.
In this case, all the definitions are combined
to create a single section in memory whose size is that
of the largest COMMON section with the given name.
Program sections, the only other type of section, must
have unique names.
Sections are listed in the ESD table
by name, type and size.

ENTRY POINT

address within a section which is named and defined
to be global ,so-that it may he use-d for the resolution
of external references in other sections. Entry points
are listed in the ESD table by name, type and address
within the section in which they occur.

2-1

EXTERNAL
SYMBOL

A symbol which is specified at assembly time to be
defined in another module as an entry point. External
symbols are listed in the ESD table by name and type.
A complete program must include entry point names
equivalent to every external symbol defined in every
module in the program. There need not, however, be an
external symbol for every entry point, nor is there any
limit on the number of modules which may contain external
symbols referencing one entry point. From a functional
viewpoint, entry points correspond to tags within a
program and external symbols correspond to references
to those tags. Every section is considered to have an
entry point at location zero of the section. The name
of this entry point is the section name.

When RALF is called from the monitor, execution begins at the tag
BEGIN.

Unless entry is via CHAIN, the OS/8 command decoder is called

to obtain input and output file designations.

If entry is by way of

CHAIN, it is assumed that the command decoder area has already been
set up by the caller.

In either case, it is always assumed that the

USR is already in core.

A check is made to determine that the first

output file is a directory device file and, if no first output file
was specified, the default file SYS:FORTRN.RL is set up.

Default output file extensions are defined if none were specified to
the command decoder, using .RL for the first output file and .LS for
the second output file.

The first output file is then opened, and the

handler for the first input file is FETCHed.

If /L or /G was specified,

the loader is looked up on SYS so that chaining will be possible.

The

symbol table, which is loader above 12000 in order to preserve the
USR, is now moved down to 10000.

Finally, the system date word is

converted to character form and stored in the title buffer.

This

completes the initialization procedure, and control is passed to
NEWLIN to collect the first line in the buffer.

At NEXTST, tests are made to determine whether the line just assembled
needs to be listed, and whether there are any remaining significant
characters in the line which have not been assembled.

2-2

If a semicolon

terminated the statement, the character pointers are bumped to skip
over it, and control passes to ASMBL to process the next statement on
the line.

If the assembler is currently 1n a REPEAT line

count is not exhausted, the current line is re-assembled.

Otherwise,

a new line is obtained in the line buffer by collecting input characters
until a carriage return is found.

If the line is longer than 128

characters, all characters after the l28th are ignored and the LT
message is printed.

The line length is calculated and saved.

At ASMBL, ASMOF is tested to determine whether the assembly is currently
inside a conditional.
but not assembled.

If so, the line is scanned for angle brackets

If not, and the first character is not a slash,

leading blanks are thrown away and control passes to LUNAME.
is a name, it is collected.

If it is followed by a comma, the symbol

is looked up in the user symbol table.
is defined as a label.

If there

If the symbol is undefined, it

If it was already defined, the current location

counter is compared with it to check for a possible MD error.

Control

then returns to ASMBL.

If the symbol found by LUNAME was followed by an equal

it is

looked up and defined according to the expression to the right of the
equal sign.

If it was followed by a space, either of the characters

, or #, or the character % and then a space, it is looked up in the
op-code table.
op-code handler.

If it is found, control passes to the appropriate
Otherwise, control is dispatched to GETEXP which

restores the character pointers saved by LUNAME, processes the rest
of the line as a single-word expression, and returns to NEXTST for the
next statement.

2-3

Expressions are processed on a strict left-to-right basis by the
routine EXPR.

A symbol is looked up, and its value is stored in

WORDI and WORD2.

It is then combined with the accumulated expressions

in EXPVAL according to the operator in LASTOP.
is then located, and the loop begins again.

A new operator (if any)

When no operator is found

after some symbol, the expression is considered complete and control
returns to the calling routine.

Undefined symbols appearing in an

expression cause output of a US message, and the value zero is used
in their place.

COMMON and section names in the symbol table have

special values (namely their lengths), but they always refer to the
starting location of the sections they define, and their values are
taken to be zero of the section so named.

If GETNAM is not able to

find a symbol in the expression, three possibilities are checked before
flagging the expression as invalid:

It may be a number, rather than a symbol.

It may be one of the characters period (representing the
current value of the location counter) or double quote
(representing the binary value of the next ASCII character).

The last operator may have been a plus sign in an indexed
FPP instruction.

At the end of expression evaluation, the console keyboard flag is
checked to ensure that the user has not typed CTRL/C to stop the
assembly.

There are six expression operator routines, one each for the operations
add, subtract, AND, OR, multiply and divide.

Except for add and

subtract, these routines must operate on absolute addresses because
the loader does not have facilities for non-additive resolution of
address constants.

2-4

The symbol table is the sale occupant of field 1, except for the OS/8
field 1 resident.

The symbol table is loaded at location 12000 to

prevent an unnecessary swap of the USR, but moved down, to start at
location 10000, during initialization.
do require a swap.

Subsequent calls to the USR

The symbol table is a set of linked lists, or,

more properly, two sets; one for user-defined symbols and one for
op-codes and pseudo-ops.

Each set contains a list corresponding to

every letter of the alphabet, and each list consists of the symbols
which start with that same letter.

Every time a symbol is encountered

in the source, the list corresponding to its first letter is searched
until a match is found, or until the end of the list or a symbol of
higher alphabetical order is found.

In the latter cases, the new

symbol is inserted into the user symbol table by changing the list
pointers so that the new symbol appears in the list in correct alphabetical order.

The pre-defined symbol table is never changed, because

the user is not permitted to define op-codes or pseudo-ops.

A RALF output file of relocatable binary data consists of two parts;
the ESD table and the text.

The ESD table contains all information

required by LIBRA or the loader, and is generated between the first
and second passes of assembly.

It serves as a partial symbol table

for the loader (the full symbol table is built up from the ESD tables
of all the modules in a program) and provides the name, attributes,
and value of every global symbol used by any module, as well as an
ESD code by which the symbol may be referred to within the text.
Every entry in the ESD table is six words long.

The first three words

are the symbol itself, packed in stripped ASCII, with two characters
per word.

The next word contains type information in the following

format:

2-5

INDICATES

A VALUE OF

Last entry in the ESD table.

The symbol is defined as external to this module.
The value of the symbol must be resolved by a
symbol of the same name appearing in the ESD
table of another module. The ESD code which
follows the type code is the code by which
references to this symbol will be identified
in the text.

The symbol is defined as an entry point in this
module.
It is therefore suitable for the
resolution of external references in other
modules.
The ESD code which follows the type
word identifies the program section in which
this entry point appears, and the value of
the symbol is relative to that section.

The symbol is defined as a COMMON section whose
size is at least as large as specified by the
value of the symbol.
If several modules contain
ESD entries referring to COMMON sections with
the same name, a single COMMON block having the
size of the largest symbol is allocated for all
of them. A name consisting of blanks is treated
in the same manner as any other name.

The symbol is defined as a section of location
independent (that is, fully word-relocatable)
code of a size equal to the value of the symbol.
The ESD code for this section allows text from
the module to be included in this section, and
relocated with respect to it.

5-17

Undefined

The text portion of a relocatable binary file consists of the binary
data to be loaded into memory, along with information directing the
loader on how to modify that data to correct the addresses for program
relocation.

The first word of text is a control word, which is made

up of a 4-bit type code and an 8-bit indicator.

Following the control

word, 9nd depending on the type code, are a number of data words to
be loaded as directed by the type code and the indicator.
word type codes are:

CODE

FUNCTION
End of text, if the indicator is zero, or no
operation otherwise.

2-6

The control

Copy the number of words given by the indicator
from text directly into memory without modification.

Re-origin to the section identified by the
indicator, with a relative location defined by
bits 9-23 of the following doubleword.
Thus,
the next two words define a new origin for the
following text, in the program section identified
by the indicator.

Relocate the following doubleword bits 9-23 by
the value of the symbol whose ESD code is
identified by the indicator.
The following
doubleword is usuall:x" a tVv"o-\vord FPP instruction,
the low-order 15 bits of which are to be relocated
by the value of the symbol identified by the
indicator.

WRITING PDP-8 CODE UNDER OS/8 FORTRAN IV

RALF contains the normal set of PDP-8 instructions (TAD, DCA, CDF, KSF,
etc.), however RALF does not allow literals, the PAGE pseudo-op, or
the use of I to specify indirect addressing.

PDP-8 code generated by

RALF is not relocatable; therefore, operations such as the following
are illegal:
EXTERN SWAP
TAD (SWAP
SWAP

/Illegal
/Under
/Rll,"LF

The character % appended to the end of a memory reference instruction
indicates indirect addressing, and the character Z indicates a page 0
reference:
CURRENT PAGE
DIRECT
INDIRECT

PAGE ZERO
DIRECT
INDIRECT

TAD A
DCA B

TADZ A
DCAZ B

TAD% A
DCA% B

TADZ% A
DCAZ% B

Spaces are not allowed between memory reference instructions and either
the Z or the % characters.

The Z must precede the % when both are used.

I.e., do not write "DCA%ZII.

Three pseudo-ops have been added to RALF:

SECT8, COMMZ, and FIELD1.

All three define sections of code and are handled in the same manner

2-7

as SECT; however, these new sections have special meaning for the
loader.

The address pseudo-op (ADDR) which generates a two word re-

locatable 15 bit address (i.e., JA TAG without use of JA) might prove
useful in 8-mode routines.

The following example demonstrates a way

in which an 8-mode routine in one RALF module calls an 8-mode routine
in another module:
EXTERN SUB
RIF
TAD
DCA

/Set DF to current
/IF for return

ACDF
.+1

/CDF X
/Make a CIF from
/Field bits

TAD
RTL
RAL
TAD
DCA

KSUB
CLL
ACIF
.+1

/CIF to field
/Containing SUB

JMS%

KSUB+l

KSUB,

ADDR

SUB

ACDF,
ACIF,

CDF
CIF

/Psuedo-op to
/Generate 15 bit
/ADDR of subroutine
/SUB

In general the address pseudo-op can be used to supply an 8-mode
section with an argument or pointer external to the section.

FPP and 8-mode code may be intermixed in any RALF section.

PDP-8 mode

routines must be called in FPP mode by either:
TRAP3 SUB
or

TRAP4 SUB

A TRAP3 SUB causes FRTS to generate a JMP SUB with interrupts on and
the FPP hardware (if any) halted.
same conditions.

TRAP4 generates a JMS SUB under the

The return from TRAP4 is:

CDF CIF 0
JMP% SUB
The return from TRAP3 is:
CDF CIF 0
JMP% RETUR..~+ 1
2-8

EXTERN #RETRN
ADDR #RETRN

RETURN,

Communication between FPP and 8-mode routines is best done at the FPP
level because of greater flexibility in both addressing and relocation
in FPP mode.

The following routine demonstrates how to pass an argu-

ment to, and retrieve an argument from, an 8-mode routine:
EXTERN SUB
EXTERN SUB IN
EXTERN SUBOUT

FLDA
FSTA

/Arg for SUB

SUBIN
TRAP 4 SUB
FLDA SUBOUT
FSTA Y

/Call SUB
/Get result

If the 8-mode routine SUB were in the same module as the FPP routine,
the externs would not be necessary.

In practice it is common for FPP

and 8-mode routines that communicate with one another to be in the
same section.

A number of techniques can be used to pass arguments.

For example, an FPP routine could move the index registers to an
8~mode

section and pass single precision arguments via ATX.

Because 8-mode routines are commonly used in conjunction with FPP code
(generated by the compiler), the 8-mode programmer should be familiar
with OS/8 FORTRAN IV subroutine calling conventions.

The general code
A

for a subroutine call is a JSR, followed by a JA around a list of
arguments, followed by a list of pointers to the arguments.
code for the statement:
CALL SUB (X,Y,Z)
would be
EXTERN
JSR
JA
JA

SUB
SUB
BYARG
X

2-9

The FPP

JA
JA

Y
Z

BYARG,

The general format of every subroutine obeys the following scheme:

RTN,
BSUB,

GOBAK,

SECT
JA

SUB
#ST

TEXT

+SUB+

SETX
SETB
FNOP
JA

XSUB
BSUB

ORG
BSUB+30
FNOP:JA RTN
FNOP:JA •

/Jump to start of
/Routine
/Needed for
/Trace back
/Reset SUB's index
/And base page
/Start of base page

/Restart for SUB
/Return to
/Calling program

Location 00000 of the calling routine's base page points to the list
of arguments, if any, and may be used by the called subroutine provided
that it is not modified.

Location 0003 of the calling routine's base

page is free for use by the called subroutine.

Location 0030 of the calling routine's base page contains the address
where execution is to continue upon exit from the subroutine, so that
a subroutine should not return from a JSR call via location 0 of the
calling routine:
CORRECT

INCORRECT

FLDA 30
JAC

FLDA 0
JAC

The "non-standard" return allows the calling routine to reset its own
index registers and base page before continuing in-line execution.
General initialization code for a subroutine would be:
SECT

SUB
#ST

BASE

2-10

#ST, STARTD
FLDA

FSTl'~

GOBJlJ<

FLDA
SETX
SETB
BASE
INDEX
FSTA

0
XSUB
BSUB
BSUB
XSUB
BSUBX

GOBAK

ISo only 2 words
IWill be picked up
/Get return JA
/Save it
/Get pointer to list
/Set SUB's XR
/Set SUB's Base
/Store pointer
/Somewhere on Base

/Set F mode before
/Return

The above code can be optimized for routines that do not require full
generality.

The JA #ST around the base page code is a convenience

which may be omitted.

The three words of text are necessary only for

error traceback and may also be omitted.

If the subroutine is not

going to call any general subroutines, the SETX and SETB instructions
at location RTN and the JA RTN at location 0030 are

~ot

necessary.

the subroutine does not require a base page, the SETB instruction is
not necessary in subroutine initialization; similar remarks apply to
index registers.

If neither base page nor index registers are modified

by the subroutine, the return sequence:
FLDl~

JAC
is also legal.

In a subroutine call, the JA around the list of argu-

ments is unnecessary when there are no arguments.

A RALF listing of

a FORTRAN source will provide a good reference of general FPP coding
conventions.

In order to generate good 8-mode code, one must be aware of the manner
in which the loader links and relocates RALF code.
three 8-mode section types:

The loader handles

COMMZ, FIELDl, and SECT8.

All three

end on page boundaries and to

types of section are forced

be a part of level MAIN; 8-mode sections never reside in overlays.
COMMZ and FIELDI sections are forced to reside in field 1; SECT

2-11

sections may be in any field.

The first COMMZ section encountered is

forced to begin at location 10000, thus enabling a page

a in field 1.

COMMZ sections of the same name are handled like COMMON sections of
the same name (i.e., they are combined into one common section).

This

feature allows 8-mode code in different modules to share page 0, provided that the modules do not destroy each other's page

a allocations.

Suppose two modules were to share page 0, with the first using location
0-17 and the second using locations 20-37:
/Module A
COMMZ SHARE
PI,
P2,
KSUBAl,
KSUBA2,

SUBAI
SUBA2

LASTA,

-1

FIELDI

1
2

/Should not go over
/20 locations

TADZ PI
JMSZ% KSUBAI
/!vlodule B
COMMZ SHARE
ORG .+20
P3,

P4,

3
4

KSUBB,

SUBB

LASTB
FIELDI

/ORG past module A's
/Page a

-2
TADZ P3

The two COMMZ sections will be put on top of one another, however,
because of the ORG .+20 in module B, they will effectively reside back
to back.

When the image is loaded, the COMMZ sections will look as

follows:

2-12

LOC

CONTENTS

1 0000
0001

1
2
SUBAl
SUBA2

2
3

1 0017
1 0020
21
22

-1
3
4

/LASTA

SUBB

-2

/LASTB

If module A is to reference module B's page 0, the procedure is:
P3=20
TADZ P3
Alternately, a duplicate of the source code for
included in module B.

CO~MZ

SHARE may be

Modules that are using the same COMMZ section

must be aware of how it is divided up.

Although COMMZ SHARE takes

only 40 locations, the loader allocates a full 200 locations to it.
All 8-mode section core allocations are always rounded up so that they
terminate on a page boundary.

If COMMZ sections of different names

exist, they are accepted by the loader and inserted into field 1, but
only one COMMZ is the real page O.

In general, it is unwise to have

more than 1 COMMZ section name.

FIELDl sections are identical to COMMZ sections in most respects.
Memory allocation for FIELDl sections is assigned after COMMZ sections,
however, and FIELDl sections are combined with FORTRAN COMMON sections
of the same name as well as other FIELDl sections of the same name.
The first difference ensures that COMMZ will be allocated page 0
storagE even in the presence of FIELDl sections.

The second allows

PDP-8 code to be loaded into COMMON, making it possible to load initialization code into data buffers.

TwoFIELDl sections with the

same name may be combined in the same manner as two COMMZ, sections.

2-13

The primary purpose of COMMZ is to provide a PDP-8 page 0; the primary
purpose of FIELDI is to ensure that 8-mode code will be loaded into
field 1 and that generating CIF CDF instructions in-line is not necessary.

SECT8 sections may not be combined in the manner of a COMMON

and are not ensured of being placed into field 1.

An 8-mode section does not have to be less than a page in length;
however, the programmer should be aware that a SECT8 section which
exceeds one page may be loaded across a field boundary and could
thereby produce disastrous results at execution time.

For this reason,

it is generally unwise to cross pages in SECT8 code.

This situation

will never occur on an 8K configuration.

If the total amount of COMMZ

and FIELDI code exceeds 4K, the loader generates an OVER CORE message.
The loader generates an MS error for any of the following:
1.

A COMMZ section name is identical to some entry point or some
non-COMMZ section name.

A F-IELDI section name is identical to some entry point or a
SECT, SECT8 or COMMZ section name.

A SECT8 section name is identical to an entry point or some
other section name.

COMMZ sections, like FORTRAN COMMONS, are never entered in the library
catalog.

For users who intend to write 8-mode code that will execute in conjunction with certain 8-mode library routines, the layout of PDP-8
FIELDI #PAGE 0 is:
LOCATION

USE

0-1

Temps for any non-interrupt time routine.

2-13

User locations.

14-157

System locations.

160-177

User locations.

Do not define any COMMZ sections other than the system COMMZ
which is #PAGEO.

2-14

If the system page 0 is desired, it will be pulled in from
the library if EXTERN #DISP appears in the code.

Do not use any part of page 0 reserved for the system.

Special purpose PDP-8 mode subroutines may be written to perform idle
jobs (refreshing a scope, checking sense lines) or to handle specific
interrupts not serviced by FRTS.

The run-time system enters idle loops while waiting for the FPP to
complete a task or for an I/O job to complete.

It is possible to

effect a JMS to a user routine during the idle loop.

RTS contains a set of instructions such as:
#IDLE, JMP

.+4

CDF
JMS

CIF
I
.-2

This sequence of instructions must be revised if an IDLE routine is to
be called.

The location #IDLE must be changed to a SKP (7410).
set to the address of the routine to be called.
to a CDF erF to the field of the routine.

#IDLE+2 must be set

This setup can be done in a

routine that is called at the beginning of MAIN.

For example:

CALL SETIDL
where SETIDL is a routine such as:

SXR,
BP,
XR,

SECT8 SETIDL
JA #RET

/Must be an 8-mode section

TEXT +SETIDL+

/Traceback information

SETX XR
SETB BP
0.0
0.0

ORG 10*3+BP

2-15

#IDLE+l must be

FNOP
JA SXR

/For trace back

o
RET,

JA •

/Return address

#RET,

STARTD
FLDA 10*3
FSTA RET
SETB BP
TRAP4 SET8

/Set up
/Return address

STARTF
JA RET
SET8,

/Field of idle

RAL

/Move to
/Bits 6-8
/CDF to #IDLE

TAD S74l0
DCA% IDPTR
TAD JOB+l
ISZ IDPTR
DCA lDPTR
TAD JOB
CLL RTL
RAL

TAD SFlELD
ISZ IDPTR
DCA% IDPTR
CDF ClF
JMP% SET8

SCDF,
SFIEL,
IDPTR,
S74l0,

/Return to main

TAD IDLAD
CLL RTL
TAD SCDF
DCA .+3
TAD lDLAD+l
DCA IDPTR

lDLAD,
JOB,

/Just for traceback
/Go to the 8 mode
/Routine set 8

EXTERN #IDLE
ADDR #lDLE
ADDR DOlT

/Address of #lDLE
/CDF goes here
/SKP
/Store at #lDLE
/Address of IDLE top routine
/Store a #IDLE+l
/Field of routine
/Position
/Store at #IDLE+2
/Set to field 0
/Return to instruction
/Following "TRAP4 SET8"

6201
6203

/15 bit address of IDLE
/15 bit address of IDLE
/Routine "DOlT"
/CDF
/CDF ClF

7410

/Skip

/The following routine performs the
/IDLE task
/Executed during IDLE loops
DOlT,

0
/Perform task
CDF CIF 0
JMP% DOlT

/Back to field 0
/And back

2-16

If the subroutine is checking for an illegal

arg~~ent,

an argu-

ment error message with traceback can be included in the subroutine
by adding two lines somewhere on the base page:
EXTERN #ARGER
EXAMER, TRAP4 #ARGER
When the error is detected in the program, effect a jump to the
TRAP 4 instruction.

For example,

FLDA%
JEQ

EXTMPI
EXAMER

FLDA
FNEG
FADD
JLT

EXTMPl

/A value of 0 is illegal

EXTMP2
EXAMER

/The value in EXTMPl must be
/greater than that in EXTMP2

Some points to note in the above example

Using a # as the first character in the name of the start
of the program assumes that the name is not called from
the FORTRAN level.
This is because # is an illegal FORTRAN
keyboard character.

If index registers 3-5 are not used by the subroutine, the
space from XR3 to the ORG statement can be used for temporary
storage, if needed.

The arguments passed from the FORTR~N level do not have to
be picked up all at once at the start of the calculation
(3-word) portion of the program ~ They can be picked up as
required during the program, can be saved in temporary space,
or accessed indirectly each time required, as best suits
the subroutine.

If a call to this routine such as Z=EXAMPL(A,B,C,D) were encountered
by the compiler, it would generate the following call to the routine:
JSR EXAMPL
JA .+10
JA A
JA B
JA C
JA D

/go to the routine
/jump around arguments
/pointer to 1st argument
/pointer to 2nd argument
/pointer to 3rd argument
/pointer to 4th argument

The A}10D routine is listed below to illustrate an application
of the formal calling sequence.

It also includes an error condi-

tion check and picks up two arguments.
code is ~_MOD(X:Y) •
2-17

When called from FORTRAN, the

I
I
I
I
I
I

A MOD

IS UBROUTI NE
SECT
ENTRY
JA
TEXT
AMODXR, SETX
SETB
BPAMOD, F 0.0
XRAMOD, F rlJ.0
AMODX, F rlJ.rlJ
ORG
FNOP
JA

AMOD(X,Y)
AMOD
MOD
HAMOD
+AMOD +
XRAMOD
8PAMOD

lrlJ*3+BPAMOD

ISECTION NAME CREAL NUMBERS)
IENTRY POINT NAME(INTEGERS)
IJUMP TO START OF ROUTINE
IFOR ERROR TRACE BACK
ISET INDEX REGISTERS
IASSIGN BASE PAGE
IBASE PAGE
IINDEX REGS.
ITEMP STORAGE
IRETURN SEQUENCE

AMODXR

AMDRTN, JA
•
IEXIT
EXTERN HARGER
AMODER, TRAP4
HARGER
IPRINT AN ERROR MESSAGE
IEXIT WITH FAC=0
FCLA
JA
AMDRTN
BASE
0
ISTAY ON CALLER·S BASE PG
ILONG ENOUGH TO GET RETURN ADDRESS
ISTART OF INTEGER ROUTINE SAME AS
MOD,
#AMOD, STARTD
ISTART OF REAL NU~. ROUTINE
FLDA
IGET RETURN JUMP
10*3
FSTA
AMDRTN
ISAVE IN THIS PROGRAM
o
FLDA
IGET POINTER TO PASSED ARG
SETX
XRAMOJ
IASSIGN MOD·S INDEX REGS
SETB
BPAMOD
IAN~ ITS BASE PAGE
BASE
BPAMO~
1, 1
LDX
FSTA
8PAMOD
FLDA7.
BPAMOD, 1
IADDR OF X
FSTA
AMODX
FLDA 7.
BPAMOD, 1+
IADDR OF Y
FSTA
8PAMOD
STARTI'
FLDA7.
BPAMOD
IGET Y
JEQ
AMODER
IY =0 I S ERROR
JGT
.+3
FNEG
lABS VALUE
F'STA
8PAMOD
FLDA7.
AMODX
IGET X
JGT
.+5
F'NEG
lABS VALUE
LDX
INOTE SIGN
",1
FSTA
AMODX
ISAV IN A TEMPORARY
FDIV
BPAMOD
IDIVIDE BY Y
JAL
AMODER
ITOO BIG.
rlJ
ALN
I F I X I T UP NO '~ •
FNORM
FMUL
8PAMOD
1M ULI TP LY IT.
FNEG
INEGATE IT.
F'ADD
AMODX
lAND ADD IN X.
JXN
AM,l
ICHECK SIGN
F'NEG
JA
AM.
AMDRTN
IDONE
2-18

RTS has its own interrupt skip chain in which all on-line device flags
are checked and serviced.
special interrupts.

This chain may be extended to handle

The external tag #INT marks the first of three

locations on RTS which have to be modified to effect a JMS to the
user's special interrupt handler.

The three locations must be set up

in exactly the same manner as that used to set up #IDLE, #IDLEl, #IDLE2
as described above.

All the same conventions hold.

Refer also to the

library subroutines ONQI and ONQB.

Three pseudo-ops have been added to RALF to help the loader determine
core allocation.

Each is a more definitive case of the SECT pseudo-op

and defines a chunk of code, thereby providing more control for the
user.

They are:
SECT8
FIELDI
COMMZ

section starts at a page boundary
section starts at a page boundary and is in field 1
section starts at page 0 of field 1

If there is more than one SECT8 section in a module, those sections
are not necessarily loaded in contiguous core.

The loader considers

core to be in two chunks - one block in field 0, and all of field 1
and above.

If there is more than one COMMZ pseudo-op in a module, they are stacked
one behind the other, but there is no way of specifying which one
starts at absolute location 0 of field 1.

COMMZ sections are

allocated by the loader before FIELDI sections.

Modules can share a COMMZ section in the same way that FORTRAN COMMON
sections can be shared.

FIELDI sections can also be shared by using

the same FIELDI section name in each module.

The first occurrence of a section name defines that section.
example,

2-19

For

SECT8 PARTA
SECT8 PARTB
SECT8 PARTA
The second mention of PARTA in the same module continues the source
where the first mention of PARTA ended at execution time.

(There is

a location counter for each section.)

To save core, a RALF FIELDI section and FORTRAN COMMON section of the
same name are mapped on top of each other, being allocated the length
of the longer and the same absolute address by the loader.

This

feature is useful for initialization (once-only) code, which can later
be overlayed by a data area.

Thus, the occurrence of FIELDI AREAl in

the RALF module and COMMON AREAl in the FORTRAN program causes AREAl
to start the same location (in field 1) and have a length of at least
200 locations (depending on the length of the RALF FIELDI section or
of the COMMON section in the FORTRAN).

If the subroutine is longer than one page and values are to be passed
across page boundaries, the address pseudo-op, ADDR, is required.
The format is:
AVARl, ADDR VARI
This generates a two-word reference to the proper location on another
page, here VARI.

For example, to pass a value to VARl, possible code

is:
00124
00125

1244
3757

00156
00157

0000 AVARl,ADDR VARI
0322

TAD
DCA%

VAR2
AVARl+l

/Value on this page
/Pass through 12-bit
/location
/Field and
/location of VARI

Any reference to an absolute address can be effected by the ADDR
pseudo-ope

2-20

If it is doubtful that the effective address is in the current data
field, it is necessary to create a CDF instruction to the proper field.
In the above example, suitable code to add to specify the data field
is:
TAD AVARl
RTL
RAL
TAD (6201
DCA .+1
0

/Get field bits
jRotate to bits 6-8
jAdd a CDF
jDeposit in line
jExecute CDFn

If the subroutine includes an off-page reference to another RALF
module (e.g., in FORLIB), it can be addressed by using an EXTERN
with an ADDR pseudo-oPe

For example, in the display program, a ref-

erence to the non-interrupt task subroutine ONQB is coded as
ONQBX,

EXTERN
ADDR

ONQB
ONQB

JMS%

ONQBX+l

and is called

The next instruction in the program is ADDR DISPLY so that DISPLY will
be added to the background list.

Execution from ONQB returns after

the ADDR pseudo-oPe

It may be desirable to salvage the first (field) word allocated by
ADDR pseudo-ops.

If the address requires only twelve bits for proper

execution, code such as
TMP,
ARG,ADDR X

TMP,ADDR X
ARG= .-1

permits TMP to be used for temporary storage because ARG+l in the left
hand example or just ARG in the right hand example defines the l2-bit
address.

RALF does not recognize LINC instruction or PDP-8 laboratory device
instructions.

Such instructions can be included in the subroutine

by defining them by equate statements in the program.

2-21

For example, adding the statements:
PDP = 2
LINC = 6141
DIS = 140
takes care of all instructions for coding the PDP-12 display subroutine.
When writing a routine that is going to be longer than a page, it can
be useful to have a non-fixed origin in order not to waste core and to
facilitate modification of the code.

A statement such as

IFPOS .-SECNAM&177-K<ORG .-SECNAM&7600+200+SECNAM>
will start a new page only if the value [current location less section
name] is greater than some K (start of section has a relative value of
0) where

K~177

and is the relative location on the current page before

which a new page should be started.

The ORG statement includes an AND

mask of 7600 to preserve the current page.

When added to 200 for the

next page and the section name, the new origin is set.
When calculating directly in a module, the following rules apply to
relative and absolute values.
relative - relative = absolute
absolute + relative = relative
OR (1), AND (&) and ADD (+) of relative symbols
generate the RALF error message RE.
When passing arguments (single precision) from FPP code to PDP code,
using the index registers is very efficient.

SUB8,

FLDA%
SETX

ARGI
MODE 8

ATX

MODE 8

/Get argument in FPP mode
/Change index registers so XRO is
/At MODE8
/Save argument

TRAP 4

SUB8

/Go to PDP-8 routine

0
TAD

MODE8,

For example,

/PDP-8 routine
MODE8

/Get argument

/Index registers set here

2-22

CHAPTER 3
THE FORTRAN IV LOADER
The FORTRAN IV loader accepts a set of (up to 128) RALF modules as
input, and links the modules, along with any necessary library
components, to form a loader image file that may be read into memory
and executed by the run-time system.

The main task accomplished by

the loader is program relocation, achieved by replacing the relative starting address of every section with an absolute core address.
Absolute addresses are also assigned to all entry points, all
relocatable binary text, and the externs.
The loader executes in three passes.

Pass 0 begins by determining

how much memory is available on the running hardware configuration,
and then constructs tables from the OS/8 command decoder input for
use by pass 1 and pass 2.
Pass 1 reads the relocatable binary input and creates the loader
symbol table.

The length of each input module is computed and

stored, along with the relative values of entry points defined within
the input modules.

When an undefined symbol is encountered, pass 1

searches the catalog of the FORTRAN IV library specified to pass 0,
or FORLIB.RL if no other library was explicitly specified, and loads
the library routine corresponding to the undefined symbol.
Pass 1 also allocates absolute core addresses to all modules and,
through them, to all symbols.

Pass 1 execution concludes by

computing the lengths of all overlay levels defined for the current
FORTRAN IV job.

Trap vectors are also set up at this time, and

the tables required for pass 2 loading are initialized.
Pass 2 concloo6s loader execution by creating a loader image file
from the relocated binary input and symbol values processed by pass 1.

3-1

LOADER PASS

(FILE COLLECTION)

00000

OS/8 Command Decoder

02000

Loader Pass 1 and
Pass 2

04600

Core measuring routine
and scratch area to
save 00000-02000
during CD calls

FIELD ~

---

06600
Unused

07600

OS/8 Field ~ resident

10000

OS/8 User Service Routine

12000

Symbol table, loader map
titles

FIELD 1

12400
13200
14000

Pass ~ code
Pass 1 initialization

16000

Module count and
module tables

17000

Library catalog header
read into this block

17600

OS/8 Field 1 resident

Pass 2 also produces the loader symbol map, if requested, and chains
to the run-time system if /G was specified.
Pass 0 contains

~ry

few subroutines.

The routine CORDSW checks for

the presence of /U, /C or /0 option specifications, as supplied to
the command decoder, and processes these options if necessary.

routine called UPDMOD is called when input to each overlay has been
concluded, to update the module counts in the module count table.

3-2

LOADER PASS 1 (SYMBOL RESOLUTION)
00000

'.,

'..L..

Utl.l.ll.Y

01400
02000
03200
04000

FIELD ~

Pass 1 and Pass 2
,,*-'

rou,-~nes

Symbol map printer
I Pass 2

Pass 1 symbol collection
Inter-pass code allocates
storage, builds and writes
Loader Image Header Block.

07600

Library catalog loads
here in 8K. Unused in
12K or more.
Input device handlers
08/8 Field rn resident

10000

E8 D .....'- a ble

04600

07200

IFIELD 1

11400
12000

8ymbol table

15400
16000

Overlay length table
Module count and module
tables (MCTTBL, MODTBL)

17200
17400

Loader header
ESD reference page

17600
20000

OS/8 Field 1 resident
Library catalog loads here
in 12K or more.
08/8 BATCH processor if
12K or more and BATCH
is running

25000

I
I

FIELD 2

CORMOV is a general core-moving subroutine, called by the instruction
sequence:

JMS CORMOV
CDF FROMFIELD
FROMADDR - I
CDF TOFIELD
TOADDR - I
- COUNT

while ERROR is the local error processing routine, called with a
pointer to the appropriate error message in the accumulator.
The major pass 1 and pass 2 subroutines, described below, operate on
the loader internal tables, whose format is presented later in this

3-3

LOADER PASS 2 (LOADER IMAGE BUILDER)
00000

Utility routines: Symbol table
look-up, TTY message handler,
OS/8 block I/O, MCTTBL
processor.

01400

Routine to print symbol map.

02000

Pass 2

03200

Binary buffer #1

05200

Binary buffer #2

07200

I/O device handlers

f----------

07600

OS/8 Field 0 resident

10000

RALF module text loads
here if 8K.

12000

Symbol table

15400

Overlay. length table

16000

MCTTBL and MODTBL

17200

Binary section table and
binary buffer (LDBUFS) table

17400

ESD reference page

17600

FIELD 1

symbol map
output buffer

OS/8 Field 1 resident

20000

Binary buffer #3, if >8K

22000

Binary buffer #4, if >8K

24000

Binary buffer #5, if >12K

26000

FIELD ~

FIELD 2

Unused

30000

RALF module text loads
here if >12K

FIELD 3

chapter.

The subroutines are presented in approximately the order

that they occur in the source listing.
SETBPT

Sets words BPTR and BPT2 to contain AC and AC+l,
respectively.

TTYHAN

Subroutine to unpack and print a TEXT message on the
console terminal. TTYHAN is called by:
CDF CURRENT
CIF 0
JMS TTYHAN
CDF MSGFIELD
MSG

3-4

RTNOS8

Prints a fatal error message and then returns to the
OS/8 monitor. A pointer to the message must follow
the JMS RTNOS8.

IOHAN

Used to execute all I/O under OS/8. The calling
sequence is:
TAD (ACARG
/Optional
CDF CURRENT
CIF 0
JMS IOHAN
ADDR
ARGl
ARG2
ARG3
where ARGl, ARG2 and ARG3 are standard OS/8 device
handler arguments and ADDR points to a three-word
block in field I which contains the OS/8 unit number
in word 1, the file length in word 2, and the starting
block number in word 3.
If ACARG is zero, the indicated I/O operation is
executed after the handler has been FETCHed, if
necessary. If ACARG=n (greater than zero), the
handler for OS/8 unit n is FETCHed, no I/O is done,
and the four arguments that conclude the calling
sequence are not needed.

ADVOVR

Called to initialize the loader to accept a new input
module. ADVOVR determines whether a new overlay or
level is being started by accessing the module count
table. If so, it sets various pointers and internal
counters accordingly, rounds the previous overlay to
terminate on a 200 word boundary, and updates the
length of the previous level, if necessary, as the
maximum of its constituent overlay lengths.

NXTOVR

Called by ADVOVR when the next input module will be
the first module in a new overlay.

SETCNT

Initializes the pointers and counters used by ADVOVR.
SETCNT is called once at the beginning of each pass.

LOOK

Executes a symbol look-up in the loader symbol table.
LOOK is called by:
TAD (Pointer to symbol name in
RALF ESD format
JMS LOOK
RETURN here if not found
RETURN here if found
GPTR points to word following entry name
If the syrr~ol is not found, it is inserted into the
loader symbol table and GPTR is set to point to the
word following the symbol name.

Produces the symbol map.

3-5

PUTSYM

Enters an ESD symbol in the loader symbol table.
PUTSYM calls LOOK to determine whether the symbol
is already present in the symbol table and, if so,
verifies that the symbol is not multiply defined.
Otherwise, it copies the ESD data words into the symbol
table entry, updates the length of the current overlay
by the length associated with the symbol, and links
the symbol to its parent symbol, if any.

FIT

Fits a section into core by subtracting its length
from the amount of core still available and substituting its load address for its length in the symbol
table.

D08S, FIT8S

Fits an 8-mode section into core by calling FIT and
then checking for field 1 overflow.

SETREF

Extracts data from the ESD table of the current module
and initializes the ESD reference page at 17400.

BLDTV

Builds the transfer vector. A transfer vector entry
is created for each subroutine in an overlay. This
entry provides the information that the run-time
system will require in order to load the overlay
containing the referenced subroutine.

NEWORG

Called whenever an origin is found in an input module,
to map the location referenced by the origin into a
block of the loader image file and an address within
that block.

NEWBB

Called whenever a new binary buffer is needed during
loader image file construction. NEWBB scans a list
of available buffers and dumps the content of the
least recently accessed buffer to free up space for
new data.

MERGE

Relocates an input word pair and outputs it to the
loader image file.

GETCTL

Gets a control byte from the input module and increments its return address by the content of the control
byte.

PUTBIN

Inserts words, sequentially, into the current binary
buffer. When the buffer is full, PUTBIN calls
NEWBB to execute output to the loader image file and
supply a new buffer.

TXTSCN

Called once for each input module. TXTSCN reads and
relocates an entire input module, executing calls to
MERGE, PUTBIN and NEWORG as needed.

3-6

SYMBOL TABLE

The loader symbol table begins at location 12000 and contains room
for 26 (decimal) permanent system symbol entries and 218 (decimal)
user entries.

Each entry is 7 words long, and provides the name and

definition of a symbol.

The table is organized in buckets

to the first character of the symbol, which must be A to
blank (for blank COMMON).

according

z, #, or

The table of bucket pointers begins at

location 12000 with the pointer to bucket A, and consists of one word
per bucket.

This word contains a value of zero, if there are no

symbols in the corresponding bucket, or else the address of the first
sx~ol

in the bucket.

Symbols within a bucket are arranged in alphabetical order, with each
symbol entry pointing to the following entry, and the last entry
pointing to zero.
lists in core.

Thus, the symbol table appears as a set of threaded

The format of a symbol table entry is:

I-bit trap
vector flag during
pass 1. Error
flag during pass 2.

WORD 2

WORD 3

3-bit

4-bit

level

overlay

4-bit type code
undefined
entry point
extern
cornmon sect
program sect

9-bit pointer to
~-~~-"-

~·~bOl

;::!;:; ..... ~"'r<

"t:"~olr:l

"""11t-';n1e pnt-rv nnint-

~:~~Hl (~~ro ~if;O"'~~)·1 bit;~

16- ~;iti~ie -~~~t ~~---~-"--

Trap vector displaceIIment
-during pass 2.

IIO-Ca.f.1Z

ADDRESS
I (Length during pass 1)
I

3-7

t:;;-

17- SECT8 sect
I

;11-FIEIDl

!12 to 17- undefined

I
!

Several special symbols are created by the loader.

The symbol #YLVLn,

where n is an octal digit, describes overlay level n.

This symbol

table entry contains the length of level n during pass 1 and the
starting address of level n during pass 2.

The symbol #YTRAP describes the trap vector, a method by which the
run-time system controls automatic overlaying of user subroutines.
Four words are allocated in the trap vector for each entry point in
every overlay except overlay #MAIN.

The symbol table entry for #YTRAP

contains the accumulated length of the trap vector during pass 1 and
the trap vector starting address during pass 2.

ESD CORRESPONDENCE TABLE (ESDPG)

The ESD correspondence table begins at location 17400 and contains
128 (decimal) I-word entries.

This table establishes the corre-

spondence between the local ESD reference numbers

used to reference

a symbol inside a RALF module, and the address of that symbol in the
loader symbol table.

The n

entry in the ESD correspondence table

points to the address of ESD symbol n.

BINARY BUFFER TABLE (LDBUFS)

The binary buffer table begins at location 17247 and contains from
two to ten entries, depending upon the amount of memory available.
Each entry is 4 words in length.

The binary buffers function as

windows into the loader image file, through which the loaded program
is written onto mass storage.
(4 OS/8 blocks) in length.

Each binary buffer is 8 pages

The loader tries to minimize the amount

of "window turning" necessary to buffer the binary data by keeping a
record of the last time each buffer was referenced.

3-8

In this way,

when the content of a binary buffer must be dumped to make room for
new data, the loader empties that buffer which was least recently
used.

In addition, program loading is overlay oriented such that only one
overlay is loaded at a time and while any specific overlay is being
loaded, only origins inside that overlay are legal.

The format of a binary buffer table entry is:

Pointer to the binary
buffer of "next earliest
reference", i.e., the youngest
buffer older than this
buffer.
contains zero if
this buffer is oldest.

WORD 1

Loader image block #.
Contains zero if buffer
has not been used.
Blocks left in current
overlay.
If <4, only
part of buffer will
be dumped.
Page address
of buffer.

WORD 2

WORD 3

Unused

I
I

WORD 4

The number of binary buffers used varies with the amount of memory
available as follows:
MEMORY
AVAIL

NO. OF
BUFFERS

8K
12K
16K
20K
24K
28K
32K

4
5
7

10 (decimal)
10 (decimal)
10 (decimal)

3-9

BINARY SECTION TABLE

The binary section table overlays the loader image header block
(described under FRTS) after the latter has been written into the
loader image file at the beginning of pass 2.

Thus, the binary

section table begins at location 17200 and contains eight 4-word
entries.

Each entry relates the core origin of one of the eight

overlay levels to that level's position in the loader image file.
The format of a binary section table entry is:

Unused

Field
of
level

WORD 1

Address of level

WORD 2

Relative block #

WORD 3

Length (in blocks)

WORD 4

OVERLAY TABLE (OVLTBL)

The overlay table begins at location 15435 and contains room for
113 (decimal) 2-word entries.

There is one entry for each overlay

defined, including overlay MAIN, with each entry designating the
length in words, of the corresponding overlay.

The format of an

overlay table entry is:

OVLTBL

Negated to indicate
last table entry

LEVEL MAIN
LEVEL 1 OVERLAY 1
.....
-~

LEVEL m OVERLAY n-l
LEVEL m OVERLAY n
OVLTBL format

I)-~

HIGH-order bits
of length
LOW-order bits
of length

/
WORD 1
WORD 2

-'---'

individual entry (2 words)

3-10

MODULE DESCRIPTOR TABLE (MODTBL)

The module descriptor table begins at location 16172 and contains
room for 172 (decimal) 3-word entries.

Each entry provides the in-

formation needed to locate an input module.

The first MODTBL entry

corresponds to the library file to be used in building the current
loader image.

Successive entries correspond to input modules and

appear

order that the modules were specified by the user,

(i.e., in ascending order by level, and ascending by overlay within
any given level.)

At the end of pass 1, entries corresponding to

individual library modules are appended to the end of the table,
even though the library modules load into level MAIN.

The table

format is:

MODTBL
FORLIB.RL or userspecified library
Level ~.AIN module #1
Level MAIN module #2

Level MAIN module #3
Level MAIN module n

---~{

File length (positive)
Starting block #
MODTBL format of

Level 1 Overlay 1 module #1
Level 1 Overlay 1 module #2
.~

Level 1 Overlay 1 module #n
'-

OS/8 I/O unit #

Level 1 Overlay 2 module #1

~
Library module #1
I

I Library module #2

'~~------.....,.--""""=--~--------'

MODTBL format

3-11

individual entry (3 words)

MODULE COUNT TABLE (MCTTBL)

The module count table begins at location 16000 and contains room for
122 (decimal) I-word entries that give the (two's complement) module
count for each overlay level.

The table format is:

MCTTBL
LEVEL

MAIN

I-word ENTRIES

LEVEL 1 OVERLAY 1
LEVEL 1 OVERLAY 2
LEVEL 1 OVERLAY 3

------

LEVEL 1 OVERLAY n

LEVEL 2 OVERLAY 1

--,---------------

LEVEL 2 OVERLAY 2

LEVEL 2 OVERLAY n

fJ
LEVEL 3 OVERLAY 1
.......

----,

- LEVEL
-----m OVERLAY n
,..

......

--"'--

fJ
fJ
If an overlay or level is not defined for a specific program, there
is no module count table entry corresponding to that overlay or level.

The loader image file, produced by the loader and read as input by the
run-time system, consists of a header block followed by a binary
image of each level defined in the FORTRAN IV job.

HEADER
BLOCK

LEVEL
MAIN

LEVEL
1

3-12

The loader image file header block contains information in the
following format:

CONTENTS

LOCATION

2 -- Identifies the file as a loader image file.

1-2

Initial SWAP arguments to load level MAIN.

3-4

Highest address used by core load, including overlays
but not including OS/8 device handlers.

Loader version number.

Double-precision flag.

7-46

User overlay information table containing one 4-word
entry per overlay level (the level MAIN entry is
ignored) in the following format:

Must

Bits 9-11
unused

Load
unused

WORD 1
WORD 2

Block number of this level,
relative to header block.

WORD 3

Length of overlays in this level,
in blocks.

WORD 4

3-13

CHAPTER 4
THE FORTRAN IV RUN-TIME SYSTEM

The FORTRAN IV run-time system supervises execution of a FORTRAN
job and provides an I/O interface between the running program and
the OS/8 operating system.

FRTS includes its own loader, which

should not be confused with LOAD, the system loader.

It executes

with only one overlay, used to restore the resident monitor and
effect program termination.

The run-time system was designed to

permit convenient modification or enhancement, and it is well documented in the assembly language source, available from the Software
Distribution Center, which includes extensive comments.
One of the most valuable modifications to FRTS provides for the
inclusion of background (or idle)

jobs.

When FORTRAN is waiting for

I/O operations or the FPP to complete execution, the PDP-8 or PDP-12
processor is sitting in an idle loop.

An idle job may be executed

by the PDP-8 or PDP-12 CPU during this time, perhaps for the purpose
of refreshing a CRT display, for example, or monitoring a controlled
process.

To indicate such a job, the idle wait loop must be modified

to include a reference to the userls PDP-8

routin~.,

The routine

#IDLE in FRTS must be changed as part of the user's subroutine from
#IDLE,

JMP .+4

CDF CIF
JMS I .-2

#IDLE,

SKP
ADDUSR
FLDUSR
JMS I .-2

Devices issuing interrupts may be added to the interrupt skip chain
so that FORTRAN checks the user's device as well as system devices.
The original code is:
#INT,

JMP .+4

CDF CIF
JMS I .-2

4-1

and must be changed, as above, to:
#INT,

SKP
ADDUSR
FLDUSR
JMS I .-2

In both cases, ADDUSR should be the address of the user's routine, and
FLDUSR should be the memory field of the user's routine.
The idle job is initiated by the subroutine HANG in the run-time
system.

Hang should only be called when the FORTRAN program must

wait for an I/O device flag.

The calling sequence is:

EXTERN #HANG
IOF
eDF n
elF 0
JMS% HANG+I
ADDRSS

/Important.
/Where n is current field.

/Return here with interrupts OFF
/When device flag is raised.
HANG,

AD DR # HANG

The word ADDRSS must point to a location in page 400 of the run-time
system which must normally contain a JMP DISMIS.

Three such locations

have been provided for the user at #DISMS, #DISMS+I, and #DISMS+2.
The selected location must be the location via which the interrupt
caused by the desired flag is dismissed.
use the same dismiss location.

No two flag routines should

The following program example illus-

trates these calling conventions.

This routine may be used to drive

a Teletype terminal via the PT08 option.

4-2

EXTERN # ONQI
EXTERN # DISMS
FIELD! GETCH
0

IJMS GETCH GETS A CHAR
IGETCH RUNS IN FIELD 1 ONLY

ISZ FIRST

JMP NOIFST
JMS7. ONQI+l
KSFI
ADDR KSF'SUB
TAD DISMIS+l
DCA HNGLOC

ISET UP TO CALL HANG

NOTFST, 101'
TAD INCHR
SZA

,."

I."I..H

JMP GOTI
elF 0

JMS7. HANG+l
HNGLOC, 0
GO Tl ,

IHANG RETURNS WI IOF

TAD INCHR
DCA FIRST
DCA INCHR
TAD FIRST
ION
JMP7. GETCH

KSFSUB, 0
KRBl
DCA INCHR
CDF CIF' 0
JMP7. DISMIS+l
INCHR,
ONQI,
HANG,
DISMIS,
FIRST,

INO CHAR READY: HANG

IINTERRUPT ROUTINE
ICALLED AS SUBROUTINE

IRETURN TO SYSTEM LOCATION
ICONTAINING "JMP DISMIS"

ADDR #ONQI
A:JDR #HANG
ADDR # DISi1S
-I

In most cases, it is easier to include references to the FORLIB
module ONQI for adding a handler to the interrupt skip chain and
ONQB for adding a job to the idle chain, instead of trying to modify
#IDLE and #INT.

ONQB provides slots for up to 9 idle jobs to be

executed round-robin, and ONQI provides for up to 9 user flags to
be tested on program interrupts.
FRTS entry points are listed, along with the core map, on the following
pages.

The FRTS calling sequence must be observed in any user

subroutine.

The formal calling sequence is illustrated below.

general, it can be used exactly as illustrated,changirig dhly the
section, entry, base page, index register and return location names.

4-3

FRTS CALLING SEQUENCE

SECT EXAMPL

EXAMXR,
BPEXAM,
XREXAM,
EXTMPl,
EXTMP2,
EXTMP3,

EXMRTN,
#EXSRT,

/Section name.
Your module may
/require another section pseudo-op
/such as FIELDI or SECT8.
JA #EXSRT
/Jump to start of subroutine
/Use # for first character
TEXT +EXAMPL+
/6 character section name for
/error traceback (optional)
SETX XREXAM
/Set up index registers
/for this subroutine
SETB BPEXAM
land its base page.
F 0.0
/Base page
F 0.0
/Index registers 0-2
F 0.0
/Index registers 3-5 (optional)
F 0.0
/Space between index registers
F 0.0
land the ORG for temporary
F 0.0
/storage (optional)
ORG 10*3+BPEXAM /Location 30 of base page
FNOP
/Force a two-word instruction
JA EXAMXR
/Jump to base page for
/return to calling program
o
/Force a two-word instruction
JA .
/Will be replaced by return jump
BASE 0
/Caller's base page
STARTD
/Start of subroutine
FLDA 10*3
/Get return jump from caller's
/base page
FSTA EXMRTN
/Save in return location for
/this routine
FLDA 0
/Location 0 of caller's routine
lis a pointer to the argument list
SETX XREXAM
/Change to EXAMPL's index registers
SETB BPEXAM
/Change to EXAMPL's base page
BASE BPEXAM
FSTA BPEXAM
/Save the pointer
LDX 1,1
/Set up index register 1
FLDA% BPEXAM, 1 /Get address of argument list
FSTA EXTMPI
/Save the addresses
FLDA% BPEXAM, l+/of all passed arguments
FSTA EXTMP2
FLDA% BPEXAM, 1+
FSTA EXTMP3
/Continue for all arguments
Ito be picked up
STARTF
FLDA% EXTMPI

/Start three-word instructions

FLDA% EXTMP2

JA EXMRTN

/Continue to get arguments
las required in routine
/Exit when done

4-4

RTS ENTRY POINT

USEAGE AND COMMENTS

#UE

TRAP3 #DE

/?roduces USER ERROR error message.

#ARGER or
# ARGERR

TRAP4 #ARGER

/Produces BAD ARG error message.

#READO

TRAP3 #READO
JA UNITNO
JA FORMAT

/Initializes
/formatted
/read operation.

#WRITO

TRAP3 #WRITO
JA UNITNO
JA FORMAT

/Initializes
/formatted
/write operation.

#RUO

TRAP3 #RUO
JA UNITNO

/Initializes unformatted
/read operation.

#WUO

TRAP3 #WUO
JA UNITNO

/Initializes unformatted
/write operation.

#RDAO

TRAP3 #RDAO
JA UNITNO
JA RECNO

/Initializes
/direct access
/read operation.

#WDAO

TRAP3 #WDAO
JA UNITNO
JA RECNO

/Initializes
/direct access
/write operation.

#RFSV

TRAP3 #RFSV

/Passes a variable to or from the read/
/write processors via the floating AC.

#RENDO

TRAP 3 #RENDO

/Terminates a read/write operation.

#ENDF

FLDA UNITNO
TRAP3 #ENDF
or TRAP3
or TRAP3 #BAK

#REW
#BAK
#DEF

/Executes an
lend file,
/re\Alind
/backspace (depending upon the entry used)
Ion the referenced I/O unit.
j

TRAP3 #DEF
JA UNITNO
JA RECORDS
JA FPNPR
JA VARIABLE

/Opens a file
/for direct access I/O.

#EXIT

JSR #EXIT

/Terminates current FORTRA~ IV job.

# SWAP

TRAP3 #SWAP
ADDR

/Reads overlay OVLY into level LVL and
/jumps to ADR. ADDR is given by:
/ADDR=4000000*OVLY+100000*LVL+ADR

#80R12

/=00000001 if the CPU is a PDP-12.

#IDLE

Address of background job, used by ONQB.
JMP I

(NULJOB

CDF CIF 0
JMS I .-2
JMP .-4

/(FPP numbers per record)
/Refer to DEFINE FILE statement

Contains:

/Replace by SKP
/Replace by addr of background job
/Replace by field of background job

4-5

CORE LAYOUT OF FRTS
NON-FPP

FPP (Same as non-FPP unless indicated)

0000

Page zero

(0120-0134 free)

0200

Most entry points, character
I/O handlers, interrupt
service, and HANG routine

0600

Format decoder; A, H, and'
format processors, and EXIT

1400

REWIND, ENDFILE, BACKSPACE
and general unit initialization. DATABL table (3 wds/unit)

2000

I, E, F and G output

2400

I, E, F and G input

2600

X, Land T formats and
GETHND routine

3000

Char in and char out routines
including OS/8 packing, editing and forms control

3400

Binary and D. A. I/O, and
DEFINE FILE processor

3600

Overlay loader

4000

Input line buffer, overlay
and DSRN tables, FORMAT
parenth pushdown list, /P
processor and init flag clear

4400

Floating-point utilities
(shift, add, etc.) used even
w/FPP

4600

Error routine and messages

5200

OS/8 handler area and part of
FRTS loader initialization

5600

FPP simulator

FPP start-up and trap routines

6000

Band D format I/O

6600

Floating-point package and
part of LPT ring buffer

7400

Most of LPT ring buffer

7600

OS/8 handler and field
o resident

10000

OS/8 User Service Routine
~~
~

Floating-point package (never used)
and part of LPT ring buffer

-----

4-6

.r'-"""-~

----- --

12000

FRTS loader tables, IONTBL

12200

FRTS loader: main flow

.........

12400

program start-up 1

12600

initialize and
configure system

13000

Load OS/8 handlers and assign
unit numbers to OS/8 files

13400

Utility and error routines,
error messages

Locations 12000 to 17400 are
overlayed at execution time

14000
15600

16600

FPP start-up and trap routines Locations 14000 to 16777 are used
to save lower field 0 during loading
B and D format I/O
of device handlers and file
specifications
EAE Floating-point package

17400

Termination routine

16000

17600

OS/8 field 1 resident
I

#INT

Locations 17400 to 17777 are
written on SYS block 37 before
program load and restored on
termination

/Address of user interrupt location, used by ONQI:
JMP .+4

CDF elF 0
JMS I .-2

/Rep1ace with SKP
/Replace wi~~ address of interrupt
processor
/Replace with field of interrupt processor

#DISMS

/Addresses first of three JMP DISMIS instructions for
use by specialized I/O routines.

#HANG

/Addresses I/O dismiss routine.

#RETRN

/Provides return from TRAP3.

lprogram start-up moves OS/8 handler to top of core, writes field
1 resident onto SYS, and termination routine goes to FRTS to load
program.

4-7

DSRN TABLE

The DSRN table controls files and I/O devices used under OS/8 FORTRAN
IV ASCII, binary and direct access I/O operations, including BACKSPACE,
REWIND, and END FILE operations.

The exact meaning of the initials

DSRN is one of the great, unanswered questions of FORTRAN IV development and, as such, has considerable historical interest.

The DSRN

table provides room for 9 entries; each entry is 9 words in length,
and contains the following data:

WORD 1:

(HAND)
Handler entry point.
If this value is positive,
the I/O device handler is a FORTRAN internal (characteroriented) handler, and the remainder of the DSRN table
entry is ignored.
If the value is negative, the handler
is an OS/8 device handler whose entry point is the two's
complement of the value. Entry points always fall in
the range [7607, 7777] for resident handlers or [5200,
5377] for non-resident handlers.
Space for non-resident
handlers is allocated downward from the top of memory,
and the handlers are moved into locations 5200 to 5577
before being called.

WORD 2:

(HCODEW)
Handler code word.
Bits 0-4 of this word specify
the page into which the device handler was loaded, while
bits 6-8 specify the memory field.
If all of bits 0-8
are zero, the handler is permanently resident. When any
of these bits are non-zero, the data is used to determine
which handler, if any, currently occupies locations 52005577. This eliminates unnecessarily moving the content
of memory. Bit 10 is set if forms control has been
inhibited on the I/O unit.
Bit 11 is set if the device
handler can execute with the interrupt system enabled.
The data in bits 10 and 11 is obtained from the IOWTBL
table in the FRTS loader.

WORD 3:

(BADFLD)
Buffer address and field.
Bits 0-4 address the
memory page at which the I/O buffer for this unit begins,
while bits 6-8 specify the memory field.
Unlike the FORTRAN
internal I/O unit buffers, OS/8 device handler buffers
always occupy two full pages of memory.
Buffer space is
allocated upward from the top of the FORTRAN program.

WORD 4:

(CHRPTR)

WORD 5:

(CHRCTR) Character counter. Words 4 and 5 of each DSRN
table entry define the current character/position in the
I/O buffer as follows:

Character pointer.

4-8

Value of
CHRCTR

Character
position

Next value
of CHRPTR

Next value
of CHRCTR

I Refresh buffer if

Bits 4-11 of word
-3

addressed by

-2

-1

input operation and

CHRPTR +

11 CHRPTR mod 256=0

CHRPTR
-2

Special
Conditions

-1

none

Bits 0-3 of words
addressed by
CHRPTR-2 and

-3

CHRPTR

CHRPTR-l

Dump buffer if
output operation and
CHRPTR mod 256=0

WORD 6:

(STBLK)

Starting block of file.

WORD 7:

(RELBLIC) Current relative block of file.
to be accessed next.

WORD 8:

(TOTBLK)

Length of file in blocks.

WORD 9:

(FFLAGS)

Status flags:

Bit 0 -

Has been written flag. Set to 1 if unit has
received output since last REWIND.

Bit 1 -

Formatted I/O flag. Set to 1 if an ASCII I/O
operation has occurred since last REWIND.

Bit 2 -

Unformatted I/O flag. Set to 1 if a binary
or direct access I/O operation has occurred
since last REWIND. Bits 1 and 2 are never
set simultaneously.

Bit 11-

END FILEd flag. Set to 1 if unit has been
END FILEd. Bit 11 is not cleared by a
REWIND.

That is, block

When any active unit is selected for an I/O operation, the DSRN table
entry for that unit is raoved into 9 ':Alords on page O.
are tagged with the labels cited above.

These 9 words

Upon completion of the I/O

operation, the 9 words are moved from page 0 back into the DSRN table.

4-9

IFORTRAN 4 RUNTIME SYSTEM - R.L

PAL8-V8

PAGE 3

IPAGE ZERO FOR FORTRAN IV RTS

00011
00012
00013

0000
0000
5402
0400
5165
0000
0000
0000
0000
0000
3777
0000
0000

00016
00017
00020
00021
00022

0016
0000
0000
0000
0000
0000

021000
00001
00002
00003
00004
00005
00006
00007
0001~

IINTERRUPT STUFF

JMP I

LPGET,
TOCHR,
KBDCHR,
POCHR,
RDRCHR,
FMTPXR,
INXR,
XR,
XR 1 ,

LP8UFR

ILINE PRINTER RING BUFFER FETCH
ITELETYPE STATUS WORD
IKEYBOARD INPUT CHARACTER
IP.T. PUNCH COMPLETION FLAG
IP.T. READER STATUS
IXR USED TO INDEX FORMAT PARE NTH
IXR USED TO GET CHARS FROM INPUT

o
o
o

o
o

INBUFR-l

*16
VEOFSW, 0
DFLG,
I NST,

.+1

I NTRPT

o
o

IUSED BY "EOFCHK" TO STORE VARIABLE ADDRESS
I*K* MUST BE IN AUTO - XR
ITEMPORARY
10 = F.P., 1 = D.P.
ICURRENT INSTRUCTION WORD

IIOH PAGE ZERO LOCATIONS
00023
00024
00025
00026
00027
00030

0000
0000
0000
0000
0000
0000

W,
0,

00031
00032
00033

0000
0000
5431

DA TCDF, 0
DATAF, 0
JMP I

00034
00035
0131336

5013
0000
5000

ERR,
FATAL,
MCDF,

RWFLAG, 0
FMTTYP, 0
EOLSVI, 0
N,
0

IREAD/WRITE FLAG
ITYPE OF CONVERSION BEING DONE
IEOL SW ON INPUT - CHAR POS ON OUT
IREPEAT FAC TOR
IFIELD WIDTH
INUMBER OF PLACES AFTER DECIMAL

0
0

DATCDF

ERROR
o
MAKCDF

ISUBROUTINE TO CHANGE DATA FIELD
ICONTAINS VARIOUS CDF·S
IRETURN
IPOINTER TO ERROR ROUTINE
IFATAL ERROR FLAG - 0=FATAL

IFPP PARAMETER TABLE LOCATIONS:
00037
00040
00041
00042
00043
00044
00045
00046
00047
00050
001351

0000
5313
0000

0000
0000
0000
0000
0000
0000
0000
0000

APT,
o
PC,
DPTEST
XRBASE, o
BASADR, o
ADR,
o
ACX,
o
ACH,
o
ACL,
o
o
EAC 1,
EAC2,
o
EAC3,
o

IVARIOUS FIELD BITS FOR FPP
IFPP PROGRAM COUNTER
IFPP INDEX REGISTER ARRAY ADDRESS
IFPP BASE PAGE ADDRESS
IADDRESS TEMPORARY

1*** FLOATING ACCUMULATOR ***
1** FOR EXTENDED PRECISION OPTION **

4-10

IFORTRAN 4 RUNTIME SYSTEM - R.L

PAL8-V8

PAGE 4

IFLOATING POINT PACKAGE LOCATIONS
00052
00053
00054
00055
00056
00057

0000
0000
0000
0000
0000
0000

AC0,
AC 1,
AC2,
OPX,
OPH,
OPL,
IRTS 110

00060
00061
00062
00063
00064
00065
00066
00067
00070
002171
0~072

00073
00074
00075
00076

0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0320
~000

6001

o
o

IFLOATING AC OVERFLOW WORD
10PERAND OVFLOW WORD

1*** FLOATING OPERAND REGISTER ***
""
SYSTEM LOCATIONS
IFORMAT BYTE POINTER
FOEIVJAT FLAG
IG FORMAT FLAG
IE FORMAT FLAG - SOMETIMES ON FOR

FMTBYT,
IFLG,
o
GFLG,
EFLG,
o
OD,
SCALE, o
PFACT, o
PFACTX, o
INESW, o
o
CHCH,
F'MTNUM, o
CTCINH, o
TTY
PTTY,

FPNXT,

IP-SCALE FACTOR
ITEMP FOR PFACT
IEXPONENT SWITCH
ICONTAINS ACCUMULATED NUMERIC VALUE
ItC INHIBIT FLAG
IPOINTER TO TTY HANDLER - USED BY
I SO FORMS CONTROL WILL WORK ON
IUSED AS INTERPRETER ADDRESS IF

'ICYCLE
"

IDSRN IMAGE

00i04
00105
00106
00107

0000
0000
0000
0000
0000
0000
0000
0000
0000

HAND,
0
HCODEW, 0
BADFLD, 0
CHRPTR, "
CHRCTR, 0
STBLK, 0
RELBLK, 0
TOTBLK, 0
Jo"FLAGS, 0

IHANDLER ENTRY POINT
IHANDLER LOAD ADDR & FIELD + IOFFL
IBUFFER ADDRESS AND FIELD
IACTUALLY A WORD POINTER
ICOUNTER - RANGES FROM -3 TO -1
ISTARTING BLOCK OF FILE
ICURRENT RELATIVE BLOCK NUMBER
ILENGTH OF FILE
IfiILE FLAGS:
IBIT 0 - "HAS BEEN WRITTEN" FLAG
IBITS 1-2 - FORMATTED/UNFORMATTED
18IT 11 - "END-FILED" FLAG

00110
00111
00112

0000
7402
5510

BUFFLD, 0
BUFCDF, HLT
JMP 1

IROUTINE TO SET DF TO BUFFER FIELD

00113

0000
0000
0000
0200

rGPBF, 0
BIOPTR, 0
FEXIT
PAGE

00077
00100
00101
00102
1?I1?I11?I7.
CJ'4IIUV

00114

00115

BUFFLD
ITHESE THREE WORDS ARE USED
ITO FETCH AND STORE FLOATING POINT
IFROM RANDOM MEMORY

4-11

IFORTRAN 4 RUNTIME SYSTEM - R.L

PAL8-V8

PAGE 5

ISTARTUP CODE
00200
00201
00202
00203

2203
6213
5603
2200

IALSO USED AS 1/0 F.P. TEMPORARY

FTEMP2, ISZ
.+3
CDF CIF 10
JMP I
.+ 1
VDA TE, RTSLDR

IUSED TO STORE OS/8 DATE

IRTS ENTRY POINTS - "VERSION INDEPENDENT"
00204

5777

VUERR,

00205
00206
00207
00210
00211
00212
00213
00214
00215
00216
00217
00220
00221
00222
00223
00224
00225
00226
1.30227
00230
00231
00232
00233

4434
2023
5634
5776
5775
5774
5773
7330
5772
7330
5771
7330
5770
5767
3000
1317

VARGER, JMS I
VRENDO, ISZ
VRFSV, JMP I
VBAK,
JMP I
VENDr, JMP I
VREW,
JMP I
J~1P I
VDEF,
AC4000
VWUO,
VRUO,
JMP I
VwDAO, AC4000
VRDAO, JMP I
VWRITO, AC4000
VREADO, JMP I
VSWAP, JMP I
VEXIT, TRAP3;

0000

0000
5766
0000
6203
4630
5227

JMP I

(USRERR IUSER ERROR
1** LOADER MUST DEFINE lARGER AS
ILIBRARY ARGUMENT ERROR
ERR
RWFLAG lEND OF 1/0 LIST
GETLMN 11/0 LIST ARG ENTRY - COROUTINE
(BKSPC I"BACKSPACE" ROUTINE
(ENDFL I"END FILE" ROUTINE
(RwIND I"REWIND" ROUTINE
(DFINE I"DEFINE FILE" ROUTINE
IUNFORMATTED WRITE
(RWUNF IUNFORMATTED READ
IDIRECT ACCESS WRITE
(RWDACC IDIRECT ACCESS READ
IFORMATTED (ASCII) WRITE
(RWASCI IFORMATTED (ASCII) READ
(SWAP
10VERLAY PROCESSOR
CALXIT I"STOP" ROUTINE - ENTERED IN FPP
10;1 IF CPU IS A PDP-12

V80R12, 0;0
V8ACKG, JMP I

(NULLJB 18ACKGROUND JOB DISPATCHER

CDF CIF 0
JMS I
.-2
JMP
V8ACKG

IUSED BY ROUTINE "ONQB" IN LIBRARY

IIOH GET VARIABLE ROUTINE.
ITHIS ROUTINE MAKES THE rORMATTED 1/0 PROCESSOR AND THE
IPROGRAM CO-ROUTINES (DEF(COROUTINE).= 2 ROUTINES EACH
I IS A SUBROUTINE).
ON ENTRY FAC=INPUT NUMBER
IIF 1/0 IS A READ, ON RETURN FAC=OUTPUT NUMBER IF 1/0
00234
00235

0000
5577

GETLMN, 0
VRETRN, JMP I

[RETURN

4-12

All FORTRAN IV mass storage I/O is performed in terms of OS/8 blocks,
including direct access I/O.

Hence, all FORTRAN IV files conform to

OS/8 standard ASCII file format.

When a formatted READ or WRITE is

requested, the data is converted to or from 8-bit binary representation according to the FOfu~T statement associated with the READ or
WRITE.

Standard OS/8 file format packs three 8-bit characters into

two 12-bit words as follows:
CORE

MASS STORAGE
WORD 3
bits 0-3

WORD 1

WORD 2

WORD 3

I bits 4-7

WORD 2
WORD 3

Unformatted (i.e. direct access) READ and WRITE operations also
operate on standard OS/8 format files, with each statement causing
one FORTRAN IV record to be read or written.

A FORTRAN IV record

must contain at least one OS/8 block, and always contains an integral
,
number of blocks. The number of variables contained in a I-block
record depends upon the content and format of the I/O list, as
follows:
Format type

Number of 12-bit
Words/Variable

Number of
Variables/Block

Integer

Real

Double precision

42 1/2

Complex

42 1/2

It is possible to mix any types of data in an I/O list; however, no
more than 85 variables may be stored in one OS/8 block.

The number

of blocks required for a FOR'fRAN IV record depends, therefore, upon
the number of variables in the I/O list, and may be minimized by
supplying every direct access WRITE with sufficient data to nearly
fill an integral number of blocks without overflowing the last block.

4-13

The last word in every file block contains a block count sequence
number and is not available for data storage.

FRTS assigns block

count numbers sequentially, beginning with 1, whenever a file is
written.

Block count numbers must be maintained by the user when

FORTRAN IV files are created outside of an OS/8 FORTRAN IV environment.

While reading a binary file, FRTS checks the block count

sequence numbers on input blocks and ignores any block whose sequence
number is larger than expected.

Sequence number checking is

disabled during direct access READ operations.

When FRTS is loaded and started, the initialization routines determine what optional hardware, such as FPP-12 Floating Point Processor
or KE8E Extended Arithmetic Element, is present in the running
hardware configuration.

The initialization routines then modify

FRTS to use the optional hardware, if available.

When an FPP is

present in the system and it becomes desirable to disable the FPP
under FRTS, this may be accomplished by changing the content of
location 12621 from 6555 to 7200.

The extended arithmetic element

may be disabled in the same manner by changing the content of FRTS
location 12623 from 7413 to 7200.
FRTS is started.

These changes must be made before

The OS/8 monitor GET and ODT commands provide an

excellent mechanism for changes of this type.

The FRTS internal line printer handler uses a linked ring buffer for
maximum I/O buffering efficiency.

The buffer consists of several

contiguous sections of memory, linked together by pointers.

All of

these buffer segments are located above 04000, so that the pointers
are readily distinguishable from bufferred characters.
07400 page is included in the line printer ring buffer.

The entire
If it

becomes desirable to modify FRTS by patching or reassembly, most
of the 07400 page may be reclaimed from the buffer by changing the

4-14

content of location 07402 from 7577 to 5164.

This frees up locations

07403 to 07577 for new code and still leaves about eighty character
positions in the LPT ring buffer.

Because FRTS executes with the processor interrupt system enabled,
it may hang up on hardware configurations that include equipment
capable of generating spurious program interrupts.

In addition,

any OS/8 I/O device handler that exits without clearing all device
flags may cause troublesome interrupts when it is assigned as a
FORTRAN I/O unit under FRTS.

To counteract these potential

problems, FRTS provides certain areas that are reserved for
inclusion of user-generated code designed to clear device flags
and/or inhibit spurious interrupts.

A string of Nap instructions beginning at location 04020 is
executed during FRTS initialization, just before the interrupt
system is enabled.

When the /H option is specified to FRTS, the

system halts after these NOPs have been executed and the interrupt
system has been enabled.

Another string of Naps occupying the

eight locations from 03746 to 03755 is executed after every call
to an OS/8 device handler.

Any of these Nap instructions may be

replaced by flag-handling or interrupt-servicing code.

additional memory locations are required, they may be obtained by
replacing some of the code from locations 04007 to 04017 with
flag-handling code.

Locations 04007-17 are used to clear flags

associated with LAB-8/E peripheral devices.

Due to memory ll.mitations, it is no"C possiole "Co add internaL -:1./0
device handlers to the four internal handlers supplied with the
system.

However, FORTRAN I/O

unit 0, which is not defined by the ANSI

standard, may be specified for terminal I/O via the internal console
terminal handler.

I/O unit 0 is not re-assignable.
4-15

IFORTRAN 4 RUNTIME SYSTEM - R.L

PAGE 6

PAL8-V8

IINTERRUPT DRIVEN 1/0 HANDLERS
00236
00237
00240
00241
00242
00243
00244
00245
00246
00247
00250
00251
00252
00253
00254
00255
00256
00257
00260
00261
00262
00263
00264
00265
00266

0000
0176
7450
5765
6002
3667
1003
7041
1267
7640
5253
1667
6666
7201
6665
1267
3267
1667
7510
5256
7640
4764
0436
6001
5636

LPT,

00267

5165

LPPUT,

LPBUFR

00270
00271
00272
00273
00274
00275
00276
00277
00300
00301
00302
00303
00304
00305

0000
7450
5765
3236
6002
1006
7640
4764
0502
1236
6026
3006
6001
5670

PTP,

o
IPAPER TAPE PUNCH HANDLER
SNA
JMP I
(IOERR IINPUT IS ERROR
DCA
LPT
ISAVE CHAR
IOF'
TAD
POCHR
IIF PUNCH IS NOT IDLE,
SZA CLA
IWE DISMISS JOB
(HANG
JMS I
PPUHNG IWAIT FOR PUNCH INTERRUPT
TAD
LPT
IOUTPUT CHAR
PLS
DCA
POCHR
ISET FLAG NON-ZERO
ION
JMP I
PTP

'AND
"
LPTSNA, SNA

[ 377

(IOERR
JtYlP I
IOF
DCA I
LPPUT
TAD
LPGET
CIA
TAD
LPPUT
SZA CLA
JMP
.+3
TAD I
LPPUT
LLS
CLA lAC
LIE
TAD
LPPUT
LPPUT
DCA
TAD I
LPPUT
SPA
• -3
JMP
SZA CLA
JMS I
(HANG
LPUHNG
ION
JMP I
LPT

IRING-BUFFERED - LP08 OR LS8E
IJUST IN CASE
ICANNOT BE USED FOR INPUT

lIS LPT QUIET?
INO

IYES - START 'ER UP
IENABLE LPT INTERRUPTS
IN AC, REMEMBER?

INEGATIVE NUMBERS ARE BUFFER LINKS
IANY ROOM LEFT IN BUFFER?
IWAIT FOR LINE PRINTER
ITURN INTERRUPTS BACK ON
IRETURN

I*K* THE FOLLOWING ADDRESSES GET FALLEN INTO & MUST BE SMAL
IFNZRO
IFNZRO
IFNZRO
IFNZRO
IFNZRO

PPUHNG&7000
TTUHNG&7000
KBUHNG&7000
RDUHNG&7000
LPUHNG&7000

4-16

< ...... ERROR4-+->
< ......

ERROR ...... >

< ...... ERROR ...... >
< ...... ERR OR ...... >
< ...... ERROR ...... >

IFORTRAN 4 RUNTIME SYSTEM - R.L

PAL8-V8

PAGE 7

IINTERRUPT-DRIVEN PTR AND TELETYPE HANDLER
00306
00307
00310
00311
00312
0121313
00314
00315
00316
00317

0000
7640
5765
6002
6014
4764
0510
1007
6001
5706

PTR,

00320
00321
00322
00323
00324
00325
00326
00327
00330
00331
00332
00333
00334
00335
00336
00337
00340
00341

0000
6002
7450
5342
3236
1004
7740
4764
0451
1004
7104
7230
1236
7510
6046
3004
6001
5720

TTY,

SZA CLA
JMP I
lOF
RFC
JMS I
RDUHNG
TAD
ION
JMP I

ICRUDE READER HANDLER
(IOERR

ISTART READER
(HANG
RDRCHR

IHANG UNTIL COMPLETE
IGET CHARACTER

PTR

IRETURN

'10345

00346
00347
00350
00351
00352
00353
00354
00355
00356
00357
00360
00361
003S2

IOF
SNA
JMP
DCA
TAD

KBD
LPT
TOCHR
SMA SZA CLA
JMS I
(HANG
TTUHNG
TAD
TOCHR
CLL RAL
CLA CML RAR
TAD
LPT
SPA
TLS
DCA
TOCHR
TTYRET, ION
JMP I
TTY

IWAIT FOR LOG JAM TO CLEAR
INO CHAR BACKED UP - SEE IF TTY
1"8USY" FLAG IN LINK - INTERRUPTS
ICOMPLEMENT OF BUSY IN SIGN
IGE1 CHAR
IIF TTY NOT BUSY,
10UTPUT CHAR
ISTORE POS OR NEG, BACKED UP
ITURN INTERRUPTS BACK ON
lAND LEAVE

PALS-V8

TAD
KBDCHR
SNA CLA
(HANG
JMS I
KBUHNG
KBDCHR
TAD
DCA
LPT
DCA
KBDCHR
TAD
LPT
JMP
TTYRET

1005
7650
4764
0465
1005
3236
3005
1236
5340

KBD,

6554
2353
5354
6552
7430
5763
6032

KILFPP, F'PHL T
ISZ
JMP
F'PICL
SZL
JMP I
KCC
GILBER, JPlS I

4-4.)4

IBUFFERS 2 CHARS ON OUTPUT, 1 ON
IDELICATE CODE AHEAD
IINPUT OR OUTPUT?
IINPUT
10UTPUT - SAVE CHAR
IGET TTY STATUS
IG.T~ 0 MEANS A CHAR IS BACKED UP

IFORTRAN 4 RUNTIME SYSTEM - ReL
00342
00343
00344

10UTPUT ILLEGAL TO PIR

PAGE 8

IHAS A CHARACTER BEEN INPUT?
INO - RUN BACKGROUND UNTIL ONE IS
IGET CHARACTER
ICHEAR CHARACTER BUFFER
IRETURN WITH INTERRUPTS ON
18RING FPP TO A SCREECHING HALT

• -1
.-1
(7600

ERR

IWAIT FOR IT TO STOP
ICLEAN UP MESS HALT HAS MADE IN FPP
11'C OR 1'B?
11'C - HIYO SILVER, AWAYI
ICLEAR KBD FLAG ON tB
1*** THISMA-¥ BE DANGEROUS!

4-17

IF'ORTRAN 4 RUNTIME SYSTEM - R.L

PAL8-V8

PAGE 9

IINTERRUPT SERVICE ROUTINES
00400
00401
00402
00403

3322
7010
3323
5207

00404
00405
004~6

0000
6203
4604

INTRPT, DCA
INTAC
RAR
DCA
INTLNK
JMP
VINT,
.+4
1** MUST BE AT 403 **
<~~~ CHANGE LOADER!!!>
IFNZRO VINT-403
0
CDF ClF' 0
IUSER INTERRUPT ROUTINE GOES HERE
JMS I
• -2

00407
00410
00411

6551
5215
5314

FPINT
Jl'llP
FPUHNG, JMP

LPTEST
DlSMIS

00412
00413
00414

5314
5314
5314

VDlSMS, JMP
JMP
JMP

DISMlS
DlSMIS
DISMIS

00415
00416
00417
00420
00421
00422
00423
00424
00425
00426
00427
00430
00431
00432
00433
00434
00435
00436
00437

6661
5240
6662
1403
7650
5314
3403
2003
1403
7510
3003
7450
1403
7440
6666
7200
6661
5314
5217

LPTEST, LSF
JMP
NOTLPT
LP TLCF , LCF
TAD I
LPGET
SNA CLA
DISMIS
J~PDIS, JMP
DCA I
LPGET
LPGET
ISZ
TAD I
LPGET
SPA
DCA
LPGET
SNA
TAD I
LPGET
SZA
LLS
CLA
LSF
DIsrYlIS
LPUH~G, JMP
Jr~p
LPTLCF

00440
00441
00442
00443
00444
00445
00446
00447
00450
00451

6041
5252
6042
1004
7540
6046
7740
7130
3004
5314

NOTL? T, TSF
JMP
NOTTTY
TCF
TOCHR
TAD
SMA SZA
TLS
SI'flA SZA CLA
STL RAR
TOCHR
DCA
DISMIS
TTUJiNG, JI"IP

ICHECK FOR F'PP DONE

4-18

IALWAYS GOES TO RESTRT

IFOR USE BY USERS

IC LEAR FLAG
ICHECK FOR SPURIOUS INTERRUPT
IGO AWAY IF SO
IZERO CHAR JUST OUTPUT

ITAKE CARE OF BUFFER LINKS
IMAKE SURE CHAR IS IN AC
lIS THERE A CHARACTER?
IYES - PRINT IT
ICHECK FOR IMMEDIATE FLAG
INO - MAYBE RESTART PROGRAM
IYES - LOO?
ICHECK TTY
ICLEAR FLAG
IGET TTY STATUS
IIF THERE IS A CHARACTER WAITING,
10UT?UT IT.
ICHANGE "WAITING" TO "BUSY",
I"BUSY" TO "IDLE".

IFORTRAN 4 RUNTIME SYSTEM - R.l

PAl8-V8

PAGE 110

IKBD AND PIP INTERRUPTS
100452
100453
100454
100455

6031
5275

00457
00460
010461
00452
100463
100464
100465

1005
1377
7110
1650
5266
6032
5314

NOTTIY, KSF
JMP
NOIKBD
[2100
lAD
KRS
KBDCHR
DCA
lAD
KBDCHR
lAD
(-2102
Cll RAR
SNA CLA
JMP
CICCTB
KCC
KBUHNG, JMP
DISMIS

00466
1010467
10104710
010471
100472
010473
100474
100475

11073
76510
5366
1323
7104
1322
6244
54100

CICCTB, TAD
CTCINH
SNA ClA
J!llP
NOIINH
lAD
INTLNK
Cll RAL
TAD
INTAC
RMF
JMP I
10

100476
00477
100500
010501
00502

61021
5303
6022
31006
5314

NOTKBD, PSI'
JMP
PCI'
DCA
PPUHNG, JMP

1175

6034

POCHR
DISMlS

00503

6011

NO TPTP, RSF

5311
1175
61012
310107
5314

JI'lP
TAD
RRB
DCA
RDUHNG, JI'lP

1010511
00512
00513
100514
1010515
010516
1010517
10105210
1010521

6663
7410
6667
1323

lPTERR, lSE
SKP
llF
DISMIS, TAD
INTlNK
CLL RAL
TAD
INTAC
RMF
ION

1322

6244
610101
5400

010522

0101010

00523

0101010

Jr~p

ICHECK FOR tC OR tB

IYUP - TAKE SOME DRASTIC ACIION
IDATA CHARACTER - CLEAR FLAG

IARE WE IN A HANDLER?
INO
/YES - RETURN WITH INTERRUPTS Off
ITRUST IN GOD AND RTS

NOT?T?

005104
00505
100506
10105107
10105110

71~4

IUSE KRS 10 FORCE PARITY BIT
lAND ALSO SO THAT tC WILL STILL

IP.T. PUNCH INTERRUPT - CLEAR FLAG
IClEAR SOFTWARE FLAG

LPTERR
[200

RDRCHR
DI5("1IS

I NT~C, 10
INTLNK, 10

4-19

IGET RDR CHAR

ITEST FOR LP08 ERROR FLAG
IDISA3LE LPeJ8 INTERRUPTS IF ERROR
IRESTORE AC AND LINK
IRETURN FROM THE INTERRUPT

IFORTRAN 4 RUNTIME SYSTEM - R.L

PAL8-VB

PAGE 11

IBACKGROUND INITIATE/TERMINATE ROUTINE
00524
00525
00526
00527
00530
00531
00532
00533
00534
00535
00536
00537
00540
00541
00542
00543

0000
1724
3371
6214
1332
3364
6203
1376
3771
1373
7104
1372
6202
6201
6001
577,4

HANG,

COME HERE WHEN THE HANG CONDITION HAS GONE AWAY

IALWAYS CALLED WITH INTERRUPTS OFF!
TAD I
HANG
IGET POINTER TO UNHANGING LOCATION
DCA
UNHANG
RDF
IGET FIELD CALLED FROM
HCIDFI{)
TAD
DCA
HNGCDF ISAVE FOR RETURN
HCIDF0, CDF CIF o
(JMP RESTNT
ICHANGE THE "JMP DISMIS"
TAD
DCA I
UNHANG ITO A "JMP RESTRT"
BACKLK
TAD
CLL RAL
BACKAC ISET UP BACKGROUND AC AND LINK
TAD
BAKCIF', CIF (()
BAKCDF, CDF I{)
ION
Jr~p I
BACKPC IINITIATE BACKGROUND

00544
00545
00546
00547
00550
00551
00552
00553
00554
00555
00556
00557
00560
00561
00562
00563
00564
00565

1222
3771
1322
3372
1323
3373
1000
3374
6234
0174
1332
3340
6234
4436
3341
2324
7402
5724

RESTRT, TAD
DCA I
TAD
DCA
TAD
DCA
TAD
DCA
RIB
AND
TAD
DCA
RIB
JMS I
DCA
ISZ
HNGCDF, HLT
JMP I

Jf1PDIS
UNHANG
INTAC
BACKAC
INTLNK
BACKLK
o
BACKPC

00566
00567
00570

1222
3771
5775

NOTINH, TAD
DCA I
Jf1P I

JMPDIS lIN CASE WE WERE HUNG, WE DON'T
UNHANG ITO GET "UNHUNG" OUT OF THE ERROR
(KILF'PP IKILL FPP AND GO TO EXIT OR ERROR

00571
00572
00573
00574

0000
0000
0000
0227
0524

UNHANG,
BACKAC,
BACKLK,
BACKPC,
VHANG:

00575
00576
00577

0353
5344
7576
0600

o
o
o
VBACKG
HANG
IFNZRO

IRESTORE THE UNHANG LOCATION
ISUSPEND THE BACKGROUND

[70

HCIOF0
BAKCIF
MCDF'
BAKCDF
HANG

I*K* OK SINCE BACKGROUND DOESN'T

HANG

IINTERRUPTS ARE OFF - RETURN

VHA NG -" 52 4

PAGE

4-20

<~~

CHANGE LOADER!>

The FRTS /P option provides a mechanism whereby the core image generated from a FORTRAN program may be punched onto paper tape in binary
loader format.

This permits the loader image to be executed on a

hardware configuration that does not include mass-storage devices.
To use the /p option, specify /P to FRTS and assign a device or file
as FORTRAN I/O unit 9.

Assigning the paper tape punch as unit 9

causes the image to be punched out directly; however, it may be desir able to direct the binary output to an intermediate file for later
transfer to paper tape via OS/9 PIP.

In any event, FRTS returns to

the monitor once the core image has been transferred.

The output file is a binary image of memory locations
and

l~~~~

~~~~~

up to the highest location used by the FORTRAN load.

~7577

The

content of each field is punched separately with its own checksum
and leader/trailer.

With the BIN loader resident in field

load the binary tape produced

under the /P option by reading each segment separately and verifying
the checksum as each memory field is loaded.

When all segments have

been read into memory, start execution at location ~~2~~.

The

following restrictions apply:

OS/8 device handlers which have been assigned FORTRAN I/O
unit numbers are not necessarily punched out. For this
reason, I/O unit assignments other than in the form /n=m
should be avoided.

With respect to the presence of an FPP and/or EAE, the configuration on which the image is punched must be identical
to the configuration on which it is to be run.
If the
punching configuration contains hardware that is absent from
the target configuration, this hardware must be disabled
under FRTS.
If the target configuration contains hardware
that is absent from the punching configuration, the extraneous
hardware will not be used.

The statements STOP and CALL EXIT cause a core load produced
under the IP optiun to halt. Any fatal erro-r flagged during
punching or execution causes error traceback followed by a
halt. Do not press CONTinue in response to either of these
machine halts.

4-21

A FORTRAN IV program is terminated in one of three ways:
1.

A fatal error condition is flagged (CTRL/B) is processed as
a fatal error.

CTRL/C is recognized, or the CPU is halted and re-started in
07600.

A STOP, CALL EXIT, or (under RALF) JSR #EXIT statement is
executed.

The sequence of events that results in program termination proceeds as
follows:
Fatal Error
(CTRL/B)

CTRL/C

BRANCH TO
ERROR
ROUTINE

EXECUTE IOF

PRINT
TRACEBACK

LET I/O DEVICE HANDLER
PROCESS tc

STOP
CALL EXIT
JSR #EXIT
SIMULATE
END FILE ON
ANY OPEN
FILES

SET NORMAL
TERMINATION
FLAG

JMP 07605

Location 07605 traps back to FRTS

At point A, FRTS executes the following operations.
1.

Read termination routine into memory.

Read OS/8 field 0 resident from block 37 of SYS.

Jump into termination routine at location 17400.

Restore normal content of locations 07600 and 07605 (in OS/8
resident).

If configuration is an in-core TD8E DECtape system, restore
second part of TD8E handler from n7600 to 27600.

Wait for TTY to finish all pending I/O.
print LF on TTY and LPT.

If normal termination flag is set, close any output files
that were opened by the FRTS loader.

Return to OS/8 monitor via location 07605.

4-22

If BATCH is running,

IFORTRAN 4 RUNTIME SYSTEM - R.L
66100

PALS-V8

FPPKG=

PAGE 78

IFOR EAE OVERLAY

123-81T FLOATING PT INTERPRETER
IW.J. CLOGHER, MODIFIED BY R.LARY FOR FORTRAN
106600
106616

7160

LPBUF2, ZBLOCK
L?BUF3

ALIBM?, 0

1010010

rACC''''

0000

106620
106621
106622
106623
106624

1240
11044

106625
06626
106621
06630
06631
106632
106633
06634
06635
06636
06637
1066410
06641
106642
106643

4171

IU\;)\;)'

06644
06645

106646
106641
~6651O

06651
106652
06653
106654
106655
106656
106657
066610
106661
106662
06663
106664

31344
4542
5611

741~

4116
4304
1044

31044
3304
31054
11045
76510
31044
4334
11056
31051
4334
1054

3046
13104
31045
11045
110104
17110
4211
11053
7710
21046
5265
21045
11045
15110
5175
721010

STA
TAD
DCA
Ji'lS I
JMP I

I*K* UTILITY SUBROUTINE
ACX
ACX

[ALl
ALIBM?

IFLOATiNG MULTIPLY-DOES 2 24X12 BIT MULTIPLIES
DDMPY, JMS I
(DARGET
SKP
(ARGET IGET OPERAND
FFMPY, JMS I
JMS
MDSET
ISET UP FOR MPY-OPX IN AC ON RETN.
ACX
TAD
100 EXPONENT ADDITION
DCA
ACX
ISTORE fINAL EXPONENT
[~DSET
DCA
IZERO TEM STORAGE FOR MPY ROUTINE
DCA
AC2
TAD
ACH
lIS FAC=IO?
SNA
CLA
DCA
ACX
IYES-ZERO EXPONENT
JMS
MP24
INO-MULTIPLY FAC BY LOW ORDER OPR.
TAD
OPH
INOW MULTIPLY FAC BY HI ORDER MULT
DCA
OPL
JMS
~P24
TAD
AC2
ISTORE RESULT BACK IN FAC
f\ ("/\
l.Ivn
A"l
v ...
ILOW ORDER
TAD
MDSET
IHIGH ORDER
DCA
ACH
TAD
ACH
100 WE NEED TO NORMALIZE?
RAL
SPA
CLA
JMS
ALl BMP IYES-DO I T FAST
TAD
ACl
SPA CLA
ICHECK OVERFLOW WORD
ISZ
ACL
IHIGH BIT ON - ROUND RESULT
JMP
MOONE
ISZ
ACH
ILOW ORDER OVERFLOWED - INCREMENT
TAD
ACH
SPA
ICHECK FOR OVERFLOW TO 4101010 100010
(SHRI
JMP I
IWE HANDLE A SIMILIAR CASE IN
CLA

4-23

IFORTRAN 4 RUNTIME SYSTEM - R.L
06665
06666
06661
06610
06611
06612
06673
06674
06675
06676
06677
06700
06701
06702
06703

3053
2333
1410
4543
1045
7650
3044
1021
7740
1044
7450
5416
7040
4541
5476

MOONE,

PAL8-V8

DCA
ACI
ISZ
MSIGN
SKP
JMS I
[FFNEG
TAD
ACH
SNA CLA
DCA
ACX
TAD
DFLG
SMA SZA CLA
TAD
ACX
SNA
JMP I
FPNXT
CMA
JMS I
(ACSR
JMP I
FPNXT

IFORTRAN 4 RUNTIME SYSTEM - R.L

PAGE 19

IZERO OVERFLOW WD(DO I NEED THIS??7
ISHOULD RESULT BE NEGATIVE?
INO
IYES-NEGATE IT
IA ZERO AC MEA NS A ZERO EXPONENT
ID.P. INTEGER MODE?
IWITH ACX LESS THAN 0?
INO - RETURN
IUN-NORMALIZE RESULT
IRETURN

PAL8-V8

PAGE 80

IMDSET-SETS UP SIGNS FOR MULTIPLY AND DIVIDE
IALSO SHIFTS OPERAND ONE BIT TO THE LEFT.
IEXIT WITH EXPONENT OF OPERAND IN AC FOR EXPONENT
ICALCULATION-CALLED WITH ADDRESS OF OPERAND IN AC AND
IDATA FIELD SET PROPERLY FOR OPERAND.
06704
06105
06706
06707
06110
06711
06712
06713
06714
06715
06716
06717
06720
06721
06722
06723
06724
06725
06726
06727
06730
06731
06132
06733

0000
7344
3333
1056
7700
5314
4774
2333
1057
7104
3057
1056
7004
3056
3053
1045
7700
5331
4543
2333
7000
1055
5704
0000

MOSET,

lEV,
MSIGN,

o
CLA CLl CMA RAl ISET SIGN CHECK TO -2
DCA
MSIGN
TAD
OPH
lIS OPERAND NEGATIVE?
SMA
CLA
INO
JMP
.+3
(OPNEG IYES-NEGATE IT
JMS I
IBUMP SIGN CHECK
MSIGN
ISZ
lAND SHIFT OPERAND lEFT ONE BIT
TAD
OPL
RAL
CLL
DCA
OPl
OPH
TAD
RAL
DCA
OPH
DCA
ACI
ICLR. OVERFLOW WORF OF FAC
ACH
TAD
lIS FAC NEGATIVE
SMA
CLA
JMP
LEV
INO-GO ON
[FFNEG IYES-NEGATE IT
Jrt'Js I
IBUMP SIGN CHECK
MSIGN
ISZ
NOP
IMAY SKIP
TAD
OPX
IEXIT WITH OPERAND EXPONENT IN AC
JlllP I
MDSET

4-24

IFORTRAN 4 RUNTIME SYSTEM - R.L

PAL8-V8

PAGE 81

124 BIT BY 12 BIT MULTIPLY. MULTIPLIER IS IN OPL
IMULTIPLICAND IS IN ACH AND ACL
IRESULT LEFT IN MDSET,AC2, AND ACt

06734
06735
06736
06737
06740
06741
06742
06743
06744

0000
1373
3055
1057
7440
5345
3053
5734
1057

MP24,

06745

'71711171

MPI
PI
1 ..
wi

06746

3057
7420
5356
1054
1046
3054
1024
1045
1304
7010
3304
1054
7010
3054
1053
7010
3053
2055
5344
5734
7764
7203
7110

106747

06750
06751
06752
06753
06754
06755
06756
06757
06760
06761
06762
06763
06764
06765
06766
06767
06770
06771
06773
06774
06775
06776
06777

.u"u

MPLP,
~,

MPLP2,

(-14
TAD
DCA
OPX
OPL
TAD
SZA
JMP
MPLP 1
AC 1
DCA
JM? I
MP24
TAD
OPL
RAR
DCA
OPL
SNL
JMP
MPLP2
AC2
TAD
ACL
TAD
AC2
DCA
CML RAL
ACH
TAD
MOSEr
TAD
RAR
lYiDSET
DCA
AC2
TAD
RAR
DCA
AC2
ACt
TAD
RAR
ACl
DCA
ISZ
OPX
JMP
MPLP
JMP I
MP24

07001

07002
07003
07£104
07012'5

lIS MULTIPLIER=0?

INO-GO ON
IYES-INSURE RESULT=0
IRETURN
ISHIFT A BIT OUT OF LOW ORDER
IOF MULTIPLIER AND INTO LINK
IWAS IT A I?
INO - 0 - JUST SHIFT PARTIAL PROD
IYES-ADD MULTIPLICAND TO PARTIAL
ILOW ORDER

I*K* NOTE THE "SNL" 5 WORDS BACKl
IHI ORDER
INOW SHIFT PARTIAL PROD. RIGHT 1

IOVERFLOW TO ACl
IDONE ALL 12 MULTIPLIER BITS?
INO-GO ON
IYES~RETURN

1::.&;111

" ........ ..,

6460
7000

PAGE

IFORTRAN 4 RUNTIME SYSTEM - R.L

07000

ISE1 UP 12 BIT COUNTER

2035
4434
1200
3044
7332
5325

PAL8-V8

PAGE 82

IDIVI:JE-BY-ZERO ROUTINE

- MUST BE .AT BEGINNING OF' PAGE

DBAD,

IDIVIDE BY 0 NON-FATAL
iGIVE ERROR l'1':) I.J

ISZ
JMS I
TAD
DCA
AC2000
JMP

FATAL
ERR
bBAD
ACX

Mroro

IRETURN A VERY LARGE POSITIVE NUM

FD
4-25

IFLOATING DIVIDE - USES DIVIDE-AND-CORRECT METHOD
a7006
07007
1217010
07011
121712112
1217013
121712114
07015
07016
1217017
071212121
0712121
1217022
0712123
0712124
121712125
121712126
1217027
071213121

4777
741121
4776
4775
712141
112144
3044
1056
7141
312156
4231
112146
312153
112157
765121
5327
1374
3231
5267

DDDI V,
FFDIV,

(OARGET
JMS I
SKP
(ARGET IGET OPERAND
JMS I
(MDSET IGO SET UP FOR DIVIDE-OPX IN AC
.1MS I
CMA
INEGATE EXP. OF OPERAND
lAC
TAD
ACX
IADD EXP OF FAC
DCA
ACX
ISTORE AS FINAL EXPONENT
TAD
OPH
INEGATE HI ORDER OPe FOR USE
lAS 01 VISOR
CLL CMA lAC
DCA
OPH
ICALL DIV.--(ACH+ACL)/OPH
JMS
DV24
ISAVE QUOT. FOR LATER
TAD
ACL
DCA
ACI
TAD
OPL
SNA CLA
JMP
DVL2
IAVOID MULTIPLYING BY 121
(-15
TAD
ISET COUNTER FOR 12 BIT MULTIPLY
DCA
DV24
ITO MULTIPLY QUOT. OF DIV. BY
JMP
DVLPI
ILOW ORDER OF OPERAND (OPL)

IDIVIDE ROUTINE - (ACH,ACL)/OPH = ACL REMAINDER REM
1217121.31
121712132
0712133
1217121.34
121712135
0712136
121712137
071214121
0712141
0712142
0712143
0712144
121712145
07046
1217047
12171215121
121712151
07052
121712153
0712154
121712155
121712156

1210121121
112145
112156
763121
52121121
1374
312154
5251
1045
71211214
312145
112145
112156
7430
312145
721210
112146
71211214
312146
212154
5241
5631

DV2 4,

DV2 ,

DV1,

0
TAD
TAD
SZL
JMP
TAD
DCA
JMP
TAD
RAL
DCA
TAD
TAD
SZL
DCA
CLA
TAD
RAL
DCA
ISZ
JMP
J:"tJP I

ACH
OPH
CLA
DBAD
(-15
AC2
DVI
ACH

ICHECK THAT DIVISOR IS .GT.
IDIVISOR IN OPH (NEGATIVE)
I I SIT?
INO-DIVIDE OVERFLOW
IYES-SET UP 12 BIT LOOP

ACH
ACH
OPH

IRES TORE HI ORDER
IN OW SUBTRACT DIVISOR FROM HI ORDER
IDIVIDEND
IGOOD SUBTRACT?
IYES-RESTORE HI DIVIDEND
INO-DON-T RESTORE--OPH.GT.ACH
ISHIFT FAC LEFT 1 BIT-ALSO SHIFT
II BIT OF QUOT. INTO LOW ORD OF ACL

IGO BEGIN DIVIDE
ICONTINUE SHIFT OF FAC LEFT

ACH
ACL
ACL
AC2
DV2
DV24

IFORTRAN 4 RUNTIME SYSTEM - R.L

IDONE 12 BITS OF QUOT?
INO-GO ON
IYES-RETN W/AC2=0

PALS-VB

PAGE 83

IDIVIDE ROUTINE CONTINUED
121712157
12171216121
0712161
121712162
0712163
0712164
121712165
121712166
0712167
0712170
07071

312157
112154
7420
5265
71121121
112146
712110
312154
112157
701121
2231

MP 12 L,

DVLPl,

DCA
TAD
SNL
JMP
CLL
TAD
RAR
DCA
TAD
RAR
ISZ

OPL
AC2

ISTORE BACK MULTIPLIET
IGET PRODUCT SO FAR
IWAS MULTIPLIER BIT A I?
INO-JUST SHIFT THE PARTIAL PRODUCT
IYES-CLEAR LINK AND ADD MULTIPLICA
ITO PARTIAL PRODUCT
ISHIFT PARTIAL PRODUCT-THIS IS HI
IRESULT-STORE BACK
ISHIFT A BIT OUT OF MULTIPLIER
lAND A BIT OR RESLT. INTO IT (LO
IDONE ALL BITS?

.+3
ACL
AC2
OPL
DV24
4-26

07072
07073
07074
07075
07076
07077
07100
07101
07102
07103
07104
07105
07106
07107
07110
07111
07112
07113
07114
07115
07116
07117
01120
07121
07123
07124
07125

5257
7141
3046
7024
1054
7161
1045
7430
5331
3045
4231
1053
7500
5325
7100
2046
7410
7001
7010
3045
1046
7010
3046
2044
7000
1045
5306
3045

07126

5773

07127
07130

3046
5304

07122

DVL3,
DVL1,
SHR1,

rD,
DVL2,

JMP
MP12L
CLL CIA
DCA
ACL
C['1L
RAL
TAD
AC2
STL CIA
TAD
ACH
SZL
JI'1P
DVOPS
DCA
ACH
JMS
DV24
ACI
TAD
SMA
JIYlP
FD
CLL
ACL
ISZ
SKP
lAC
RAR
DCA
ACH
TAD
ACL
RAR
DCA
ACL
ISZ
ACX
NOP
ACH
TAD
Jl'rJP
DVL1+1
DCA
ACH
(MDONE
JMP I
DCA
JI"'P

ACL
DVL3

IFORTRAN 4 RUNTIME SYSTEM - R.L

INa-LOOP BACK
IYES-LOW ORDER PROD. OF QUOT. X
INEGATE AND STORE
IPROPAGATE CARRY
INEGATE HI ORDER PRODUCT
ICOMPARE WITH REMAINDER OF FIRST
IWELL?
IGREATER THAN REM.-ADJUST QUOT OF
10K - DO (REM - (Q*OPL» I OPH
IDIVIDE BY OPH (HI ORDER OPERAND)
IGET QUOT. OF FIRST DIV.
IIF HI ORDER BIT SET-MUST SHIFT
INO-ITS NORMALIZED-DONE
IROUND AND SHIFT RIGHT ONE
IDOUBLE PRECISION INCREMENT
IS TORE IN FAC
ISHIFT LOW ORDER RIGHT
/STORE BACK
IBUMP EXPONENT
/IF FRACT WAS 77777777 WE MUST
ISTORE HIGH ORDER RESULT
/GO LEAVE DIVIDE
ICOME HERE IF LOW-ORDER QUO=0
/SAVE SOME TIME

PALS-V8

PAGE 84

IROUTINE TO ADJUST QUOTINET OF FIRST DIVIDE (MAYBE) WHEN
IREMAINDER OF THE FIRST DIVIDE IS LESS THAN QUOT*OPL
INEGATE AND STORE REVISED REMAINDER

07131

7041

CMA

lAC

07132

3045

DCA

ACH

07133
07134
07135
07136
07137
07140
07141
07142
07143
07144
07145
07146
07147
07150
07151
07152
07153

7100
1056
1045
7420
5344
3045
7040
1053
3053
7300
1045
7450
3046
3045
4231
1046

07154

3046

CLL
TAD
OPH
TAD
ACH
SNL
JI't}P
DVOP 1
DCA
ACH
CMA
TAD
ACI
DCA
ACl
CLA
CLL
TAO
ACH
SNA
DCA
ACL
DCA
ACH
JMS
DV24
TAD
ACL
CLL CMA lAC
DCA
ACL

071-S-S

07156
07157

7141

7420

7040
5305

DVOPS,

DVOPl,
DVOP2,

SN-L

CMA
JrtJP

DVLl

4-27

IWATCH FOR OVERFLOw
IOVERFLOW-DON'T ADJUST QUaT. OF 1
INO OVERFLOW-STORE NEW REM.
/SUBTRACT 1 FROM QUOT OF
IFIRST DIVIDE

IGET HI ORD OF REMAINDER
lIS IT ZEHO?
IYES-MAKE WHOLE THING ZERO
/DIVIDE EXTENDED REM. BY HI DIVISOR
INEGATE THE RESULT

llF QUOT~ IS NON-ZERO, SUBTRACT
lONE FROM HIGH ORDER ~UOT.
/GO TO IT

0116_0

aflHl0

1217172
1217173
1217174
1217175
1217176
1217177

7316
6665
7763
671214
6514
646121

LPBUF3, Z-BLOCK
lPBUF'4

PAGE

721210

IFORTRAN 4 RUNTIME SYSTEM - R.L

PAl8-V8

PAGE 85

r-NRMFAC" AND "OPNEG" MUST 8E AT 0 AND 3 ON PAGE
12172121121
121721211
121721212

312153
4271
5476

NRMF AC, DCA
JMS
JIVlP I

121721213
121721214
121721215
07206
121721217
07210
1217211
07212
1217213

121121121121
112157
7141
312157
7024
1056
7141
312156
561213

OPNEG,

07214
07215
1217216
1217217
0722121
1217221
1217222
07223
1217224
1217225

1217226
1217227
121723121
1217231
1217232
1217233
1217234
07235
07236
1217237
0724121
1217241
1217242
07243
1217244
1217245

4777
421213

741121
4777
1056
7550
5476
112145
765121
5236
112144
7141
112155
754121
5243
712141
4246
4541
112155
312144
4537
4271
5476
4541
4246
5236

ACI
F'FNOR
FPNXT

121
TAD
OPl
ClL CMA lAC
DCA
OPL
CMl
RAl
TAD
OPH
Cll CI~A lAC
DCA
OPH
JMP I
OPNEG

IKILL OVERFLOW BIT

IROUTINE TO NEGATE OPERAND
IGET LOW ORDER
INEGATE AND STORE BACK
IPROPAGATE CARRY
IGET HI ORDER
INEGATE AND STORE BACK

I
IFlOATING SUBTRACT AND ADD
I
(ARGET IPICK UO THE OPe
F'F'SUB, JIVlS I
JMS
OPNEG
INEGATE OPERAND
SKP
(ARGET IPICK UP OPERAND
FFADD, JMS I
TAD
OPH
lIS OPERAND = 121
SNA
ClA
JMP I
IYES-DONE
FPNXT
ACH
INO-IS FAC=0?
TAD
SNA
CLA
IYES-DO ADD
JMP
DOADD
INO-DO EXPONENT CALCULATION
ACX
TAD
Cll C(~A lAC
TAD
OPX
SMA
IWHICH EXP. GREATER?
SZA
IOPERANDS-SHIFT FAC
JMP
FACR
IFAC'S-SHIFT OPERAND=DIFFRNCE+l
lAC
CMA
JMS
OPSR
[ACSR
ISHIF'T FAC ONE PLACE RIGHT
Jf1S I
ISET EXPONENT OF RESULT
OPX
DOADD, TAD
ACX
DCA
[OADD
100 THE ADDITION
Jr1S I
INORMALIZE RESULT
Jf1S
FFNOR
IRETURN
JMP I
FPNXT
JI~S
ISHIFT FAC = DIFF.+1
FACR,
I [ACSR
OPSR
ISHIFT OPR. 1 PLACE
JMS
100 ADDITION
Jf1P
DOADD

4-28

IFORTRAN 4 RUNTIME SYSTEM - R.L

PALS-VB

OA~C'

MU~

t.L1:

10PERAND SHIFT RIGHT-ENTER WITH POSITIVE COUNT-l IN AC
07246
'07247
07250
07251
07252
'07253
07254
07255
07256
07257
07260
07261
07262
'07263
07264
07265
07266
07267

00'0'0

OPSR,

3'054

CMA
DCA
TAD
CLL
SPA
CML
RAR
DCA
TAD
RAR
DCA
!SZ
NOP
ISZ
JMP
RAR
DCA

07270

5646

JMP I

07271
07272
07273
07274
07275
07276
07277
07300
'07301
'073'02

00'00
1'045
74521
1046
745'0
1053

07303

en 304
07305
07306
'073'07
'0731'0
07 ~ 11
'07312
'07313
07314
07315
07316
07376
'07377

7040
3052
1056
7100
7510
702'0
701'0
3'056
1051
7010
3'057
2055
7000

LOP2,

2'052

5251
7'0l~

7650
5313
7332
1045
7440
53'07
1046

764'0

7710
5314
4534
53'01
3044
3053
5671

'00'00

7400
6514
74'00

/- (COUNT+l) TO SHIFT COUNTER
AC'0
OPH

OPH
OPL

IGET SIGN BIT
ITO LINK
IWITH HI MANTISSA IN AC
ISHIFT IT RIGHT, PROPAGATING SIGN
ISTORE BACK

OPL
OPX

ISTORE LO ORDER BACK
IINCREMENT EXPONENT

AC0
LOP2

IDONE ALL SHIFTS?
INO-LOOP
ISAVE 1 BIT OF OVERFLOW
lIN AC2
IYES-RETN.

AC2
OPSR

IROUTINE TO NORMALIZE THE FAC
ACH
IGET THE HI ORDER MANTISSA
TAD
SNA
IZERO?
TAD
ACL
IYES-HOW ABOUT lOW?
SNA
ACI
ILOW=0, IS OVRFlO BIT ON?
TAD
ClA
SNA
JMP
ZEXP
1#='0-ZERO EXPONENT
NORMlP, CLA ClL CML RTR INOT 0-MAKE A 2000 IN AC
ACH
IADD HI ORDER MANTISSA
TAD
SZA
IHI ORDER = 6000
JM?
INO-CHECK LEFT MOST DIGIT
.+3
TAD
ACL
IYES-6000 OK IF lOW=0
SZA
CLA
SPA
CLA
12,3,4,5,ARE LEGAL LEFT MOST DIGS.
JMP
FFNORR IFOR NORMALIZED 6-(+2000=4,5,6,7)
JMS I
[ALIBMP ISHIFT AC LEFT AND BUMP ACX DOWN
JMP
NORMLP IGO BACK AND SEE IF NORMALIZED
ACX
ZEXP,
DCA
FFNORR, DCA
ACI
IDONE W/NORMALIZE - CLEAR ACI
JMP I
FFNOR
IRETURN
FFNOR,

LPBUF4, ZBLOCK
lPBUFE

6'0

PAGE

4-29

CHAPTER 5

LIBRA AND FORLIB

The binary output of an assembly under RALF is called a RALF
module.

Every RALF module consists of an External Symbol Dictionary

(or ESD) and associated text.

The ESD lists all global symbols

defined in the assembly, while the text contains the actual binary
output along with relocation data.
There are three major classes of global symbols.

Entry points are

global symbols defined in a module and referenced by code in other
modules.

Thus, entry points include the names of all modules and

the names of all globally callable subroutines within modules.
Externs are global symbols that are referenced in a module but not
defined in that module.

For example, the entry point of module A

would appear as an extern if referenced in module B.

The COMMON area

comprises a third class of global symbols including all global
symbols which define CO~~ON.

A FORTRAN IV library is a specially formatted file, created with
LIBRA, consisting of a library catalog (which lists section names
and entry points of library modules) and a set of RALF modules;
perhaps interspersed with empty

subfiles.

The loader uses one

such library, specified by the user, to resolve externs while
building a loader image file.

The general structure of a FORTRAN IV

library is:

CATALOG

MODULE

FREE

MODULE

AREA

MODULE
etc.

5-1

LIBRA is a very simple program, basically a file-to-file copy inside
several nested loops.

The outer loop begins at START, and calls the

command decoder for specification of the library and input files.

no library is specified, the previous library name is used (initially
this is SYS:FORLIB.RL).

If a new name is given, but no extension is

specified, .RL is forced.

A check is made to verify that the spec-

ified library is on a file-structured device, and the handler is
FETCHed.

At ZTEST, the /Z switch is tested.
NEWLIB to create a new library.

If it was set, control passes to

Otherwise, an attempt is made to find

an old library of the specified name on the device.
control passes to NEWLIB.

If it fails,

Otherwise, the catalog of the old library

is read and scanned to determine the starting block of available
space.

This is stored at LAVAIL.

Control then passes to GETINF to

begin reading input files.

If /Z was set, or the specified library isn't found, a new library
is entered at NEWLIB, and an empty catalog is written.
to GETINF.

Control passes

There, a check is made to determine whether input is

presently coming from another library.

If it is, control passes to

INLIB to obtain the next module from the library.

Otherwise, the

next input file is obtained from the command decoder area in field 1,
and if one exists, control passes to FTCHIN to load the handler.
there is none, the /C switch is tested.

If it is not set, control

is passed to LCLOSE to close the library.

If it is set, however,

the command decoder is recalled to obtain a continuation of the
preceding input line, and control returns to NXTINF to look in the
command decoder area.

5-2

At FTCHIN, the unit, starting block, and length of the next input
file are obtained from the command decoder area, the appropriate
device handler is fetched, and at LUKMOD, the input file is read to
ensure that it is either a module or a library.

If a library, control

passes to GOTLIB, which sets INLSW and goes to INLIB to obtain the
first module from the

Otherwise, the length is checked

against the available length in the library, to ensure that this
module can be fit in, and control goes to NXTEBK to read the ESD.

At INLIB, the catalog of the library being input is read, and scanned
until a module is found with a starting block greater than the starting block of the last input module (in the case of the first module
in a library, MODBLK, which normally contains the starting block of
a module, contains the starting block of the library, so this scan
yields the starting block of the first module in the library).

When

the next module has been found, control returns to LUKMOD to check
the length of the module against the available length in the library.

At NXTEBK, the end of the input module is scanned for entry point and
section names.

Whenever one is found, the catalog of the output

library is scanned for a matching name.

If a match is found, control

passes to GOTMAT, which prints the duplicated name, and if the /1
switch is set, asks the operator which name to keep.

If he types N,

for new, control passes to DLETO to delete the old name.

Otherwise,

control is passed to ESDLND to find the next entry point or section
name in the input.

If /1 is not set, /R is tested.

control is passed to ESDLND.

If it is not set,

If it is, control flows into DELTO,

where the old na~e is cleared: and the rest of the catalog is scanned
to find the first available name slot.

5-3

Control then passes to INSERT.

If no match was found, the II switch is tested.

If it was set, the

operator is asked whether to include the name.

If he types, N, for

no, control is passed to ESDLND.

Otherwise, or if II was not set, a

pointer is set up for the new name, and control passes to INSERT,
where the new name is added to the catalog.

When the entire ESD has been scanned, INCLUD is tested to determine
whether any name has been included in the catalog, and assuming at
least one has, the module is copied into the library, and LAVAIL is
updated to indicate the next available block in the library.

Control

returns to GETINF for another module.

LCLOSE receives control whenever the end of the input file string is
reached and

IC is not set.

Here, any remaining changes in the library

catalog are written, and if a new library was entered, it is closed.
Control passes to CATLST, to create a catalog listing.

The second

output file, if any was specified, is opened, a title is output to it,
and at PRCAT, the entire contents of the catalog are listed.

When

this process is complete, the output file is closed, and control
returns to start for more command decoder input.

5-4

User-coded modules may be added to the system library or incorporated
in a new library provided that entry points, variable storage allocations, calling sequences, error conditions and the like are handled
with care.

Every library module must have a unique section (and entry) name(s).
The library supplied by DEC uses the character # before names where
duplication in the FORTRAN program may be possible.

Note that this

character is acceptable to RALF, but is illegal in a FORTRAN source.

If more than one entry is required to the routine, they should be
listed as such using the pseudo-op ENTRY before they are encountered
as tags in the code.

Thus, if a double precision tangent routine is

being written, it may be helpful to have an entry for a double precision co-tangent calculation also.

Appropriate code would be:

SECT DTAN
JA #DTAN
ENTRY DCOT
JA #DCOT

#DCOT,
#DTAN;

When routines will handle double precision or complex values, allocate
six words for their storage.
STARTF (3 word format)

Such routines can switch between the

and STARTE (6 word format) pseudo-ops as re-

quired, being careful to define variables of the proper length to
keep track of temporary locations.

5-5

All user-written library routines are called by a JSR in STARTF mode.
Depending on the type of function, the routine must be coded to exit
as follows in order to return the result to the program:
Single preC1S10n
(integer, real and logical)
FLDA ANSWER
JA RETURN
Double precision:
FLDA ANSWER
JA RETURN
Complex:

Answer in AC in STARTF mode
/In STARTF mode
/3 word result
Answer in AC in STARTE mode
/In STARTE mode
/6 word result
Answer in location #CAC in
STARTE mode

EXTERN #CAC
STARTE
FLDA ANSWER
FSTA #CAC
JA RETURN

/Real part in first 3 words
/Imaginary in last 3 words
/Exit in STARTE mode
/6 word result

Routines should conform to the FPP FORTRAN calling sequence.

example of that sequence follows:
SECT DTAN
JA
#DTAN
TEXT +DTAN +

DTANXR,

SETX XRDTAN
SETB BPDTAN

BPDTAN,
XRDTAN,

F ~.~
F ~.~

ORG 10*3+BPDTAN

/Sector name
/Jump to Start of Function
/6 characters for trace
/back feature must be
/immediately before index
/register assignment.
/This tag referenced when
/returning to reset base
/page and index registers
/if this routine called.
/3 words each
/These locations may be
fused for temporary storage or
/If this routine is called,
/will set up return to it.

FNOP
JA DTANXR
~

DTNRTN,
#DTAN,

JA
BASE ~
STARTD
FLDA 10*3
FSTA DTNRTN

/Return to calling program
/Still on caller's base page
/Start of subroutine
/Get jump to caller's return jump
/Save for return from this routine

5-6

FLDA ~

/Get next location in caller's
/routine (pointer to argument list)
/Change index registers to this
/routine's
/Change base page to this routine's
/Change base page to this routine's
/Save pointer
/Set up XRL
/Get address of argument list
/Save it
/A double precision routine
/Get variable
/Save variable

SETX XRDTAN
SETB BPDTAN
BASE BPDTAN
FSTA TEMP
LDX 1,1
FLDA% TEMP,l
FSTA TEMP
STARTE
FLDA% TEMP
FSTA TEMP

/Calculate result

FLDA ANSWER
JA DTNRTN

/Load answer
/Exit

The following conventions must be observed to return to the calling
program at the correct location, to permit the error trace back
feature to function properly, and to preserve index registers and
base page integrity.

Locations ~ and

of the called (user-coded) program are determined

by a statement in the form ORG lO*3+BPAGE which must be followed by
a two-word jump to the index register and base page assignment instructions JA BPXR.

In the above example, the code is:

ORG 10*3+BPDATN
FNOP
JA DTANXR
By saving the contents of location 30 of the calling prog.am (FLDA
10*3,FSTA RETURN) for the return exit, the called program executes
(when control is returned to it) a JA BPXR to its base page and index
register assignment statement.

In the calling program this resets

the index registers and base page and then returns to execute the
instruction in the calling program.
the code is:

5-7

In the tangent example above,

FLDA 10*3
FSTA DTNRTN
which creates the instruction
JA xxx
at the tag DTNRTN, where xxx is the location in the calling routine
whose function corresponds to DTANXR in DTAN.

When called, the routine must assign its own base page and index
registers (SETX XROWN, SETB BPOWN).

If arguments are to be passed

to the called routine, a scheme such as illustrated above permits
any number of arguments to be passed from the calling program and
saved on the base page of the called program, in this case just
two arguments.

The corresponding code for the calling program (as created by the
compiler) is:
EXTERN DTAN
JSR DTAN
JA .+4
JA A

/Jump past all arguments
/Argument

FSTA Q

/Save result in some variable

The FORTRAN for such code is:
Q

DTAN (A)

The calling sequence is also discussed in Chapter 2.

To permit the error trace back feature to function properly, a TEXT
statement followed by a six alphanumeric character name is required
immediately before the index register and base page assignment
statements.

Thus, if the

cota~gent

5-8

routine includes a JSR TAN and an

unacceptable argument is passed to the tangent function, the trace
back indicates the location of the problem by a sequence such as:
DIVa MAIN
ARGUMENT
7777 SIN
0000 TAN
0000 COT
0007 MAIN
(Line numbers are not relevant in RALF modules such as
they are meaningful only in

FORTR&~

T&~

and SIN:

source progra~s.)

A new library routine may call other new or existing library routines
as part of its function, as well as the error handling function of
the run-time system.

To invoke the error message program, code such

as the following is required:
EXTERN
MERROR, TRAP4

#ARGER
#ARGER

Then any condition encountered in the program that is an error should
jump to MERROR.

For example, if an argument of

is illegal, it

could be examined and handled as follows:
FLDA%
JLE
FSTA

ARG2
MERROR
NEXT

/<~

error
Save non-zero value

In this case, the TRAP4 #ARGER at MERROR will produce the message
BAD ARG DTAN nnnn followed by traceback and program termination.
If a new library routine would like to use an existing library routine,
a JSR to that routine is required.

The sequence for passing arguments

is:
EXTERN
JSR
JA

ATAN2
ATAN2
.+6

A
B

JA
FSTA

ANSWER

/Execute upon exit from
lIst arg
/2nd arg
/Save answer

5-9

The arguments must be referenced in the order expected by the called
routine and must agree in number and type.

The following routines

can be used in this manner:
ROUTINE

ARGUMENTS PASSED

AMOD
SQRT
ALOGIO
EXP
SIN
COS
TAN
SIND
COSD
TAND
ASIN
ACOS
ATAN
ATAN2
SINH
COSH
TANH
DMOD
DSIGN
DSIN
DLOG
DSQRT
DCOS
DLOGIO
DATAN2
DATAN
DEXP
CMPLX
CSIN
CCOS
REAL
AI MAG
CONJG
CEXP
CLOG
CABS
CSQRT

Address of X then y
Address of X
Address of X
Address of X
Address of X
Address of X
Address of X
Address of X
Address of X
Address of X
Address of X
Address of X
Address of X
Address of X then Y
Address of X
Address of X
Address of X
Address of X then Y
Address of X then Y
Address of X
Address of X
Address of X
Address of X
Address of X
Address of X then Y
Address of X
Address of X
Address of X
Address of X
Address of X
Address of X
Address of X
Address of X
Address of X
Address of X
Address of X
Address of X

For real and double precision routines, the result is returned via
the FAC (3 or 6 words, respectively).
result is returned in #CAC (6 words) •

5-10

For complex routines, the

The TAN function from FORLIB is included here as an example of the
requirements just discussed.

The TAN function calls two external

standard calling sequence, and contains an error
condition exit.

I
TA N
I
I
ISUBROUTINE
SECT
JA
TANER,
TA NXR,
BTAN,

EXTERN
TRAP4
TEXT
SETX
SETB
FNOP

TAN(X)
TAN
# TAN

ISECTION NAME
IJUMP AROUND BASE PAGE

Jl.!\O~t"o

1T MI\ \,01 Lol\

#ARGER
+
+TAN
XRTAN
BPTAN

IEXIT TO ERROR MESSAGE HANDLER
IFOR ERROR TRACE BACK
ISTART OF FORMAL CALLING SEQUENCE
ISTART OF BASE PAGE

0
0

XR TAN,
TAN 1 ,
TAN2,

F 0.0
F 0.0

IINDEX REGISTERS
ILOCATIONS 21-42 OCTAL AVAILABLE
IFOR USER STORAGE

F' 0.0

ORG

10+.3+BPTAN

FNOP
JA

ISET UP FOR A RETURN
ITO THIS ROUTINE

TANXR

IJUMP TO XR + RP ASSIGNMENT

T.~NRTN,

# TAN,

JA
BASE
STARTO
F'LDA
FSTA
FLDA
~r.'·T'v

.,r..ll\

10*.3
TANRTN
0
XRTAN

ISAVE RETURN JUMP
IGET NEXT LOCATION
lIN CALLING PROGRAM
I~~l ur run TAN'S ~NU~A REGS
ISET UP FOR TAN'S BP

SETB
BASE
LDX
FSTA
FLDA7.
FSTA
STARTF
FLDA7.
JEQ
FSTA
EXTERN
JSR
JA
JA

BPTAN
BPTAN

JE(~

TAN~R

/COS=0.

F'ST.~

TAN2
SIN

ISAVE IT

EXTERN
JSR
JA
JA
FDIV
JA

1, 1

BPTAN
BPTAN,l
BPTAN
BPTAN
TANRTN
TANI
COS
COS
.+4
TANI

SIN
.'T4

TANI
TAN2
TANRTN

IGET ADDRESS OF X
IGET X
IIF 0 RETURN NOW
ISAVE FOR A SECOND
ITAKE COS(X)
IJUMP AROUND ARGUMENT LIST
IREFERENCE TO PASSED ARGUMENT

~ ", ('\ i.1

Il1iUW

A \J' C'"

!Hnt:..

A NO-NO

I AI ,

.,t.Jl'I~I\J

IJOMP AROUND ARGUMENT LIST
IREFERENCE TO ARGUMENT
IDIV BY COS(X)
IEXIT

5-11

The library routine ONQI illustrates many of the same conventions.
This listing may also prove valuable as a guide to interfacing with
the run-time system.

FIELDl ONQI
IHANDLER TO INTERRUPT SKIP CHAIN
IPUT THIS CODE IN FIELD 1

IROUTINE TO ADD A

JMP
SETINT
ISET UP INT INITIALLY
ONQI
ISZ
IBUMP ARGUMENT POINTER
ISZ
INTQ+l
IBUMP INTERRUPT Q POINTER
DCA?
INTQ+l
ISTICK lOT ONTO INT Q
TAD
XSKP
IFOLLOWED BY A SKIP
ISZ
INTQ+l
DCA?
INTQ+I
10NTO INT Q
ONQI
ISZ
ISKIP FIRST WORD OF ADDR
INTQ+l
ISZ
ONQISW, TAD?
ONQI
IGET INT HANDLER ADDRESS
ONQI
ISZ
DCA?
INTADR+l
10NTO ADDRESS STACK
INTADR+l
TAD
INOW MAKE JMS?
L177
AND
L4600
TAD
INTQ+l
DCA?
10NTO INT Q
ISZ
INTADR+l
IQSIZE
ISZ
IROOM F'OR MORE?
ONQI
JMP?
IYES
• -1
TAD
INO, CLOSE OUT THE SUSR
DCA
ONQI+l
JMP?
ONQI
SETINT, TAD
ONQISW
IDO THIS PART ONLY ONCE
DCA
ONQI+l
CDr
TAD
XSKP
IFIX UP HINT
DCA?
XINT+l
IPUT SKIP INST. FIRST
ISZ
XINT+l
TAD
INTQ+l
DCA?
XINT+I
IGET ADDR. OF' USER'S ROUTINE
ISZ
XINT+l
IADD TO INTERRUPT CALL
TAD
CIFCDF
IGET FIELD INSTRUCTION
IFIELDI SECTION INSURES ITS IN FIELD I
DCA?
XINT+I
CIF'CDF', CDF' CIF' 10
JMP
ONQI+l
IBACK TO ONQI
EX TERN lINT
XINT,
ADDR
lINT
IPOINTS TO INT RTN IN COMMON
INTQ,

ADDR

IHANDL

IMUST USE 15 BIT ADDRESS

INTADR, ADDR

IHADRS

IQSIZE,
XSKP,
L177,
L4600,

-5
SKP
177
4600
CDF' CIF'

J~??'
IHANDL
IHANDL, 0
REPEAT 16
JMP
IHANDL-2
IHA DRS, 0;0;0;0;0

leAN SET UP 1-5 DEVICES
5-12

ONQB
IUSE "ENTRY" TO PERMIT
ENTRY
IACCESS FRO~ OUTSIDE OF SECTION
IROUTINE TO SET UP AN IDLE JOB
ONQB,
0
JMP
ISETUP #IDLE
SETBAK
IGET ADDRESS OF IDLE JOB
ONQB
TAD7.
ONQB
ONQBSW, ISZ
BAKADR+l
DCA7.
ISTORE ONTO BACKGROUND JOB Q
TAD
IMAKE A JMS7.
BAKADR+l
BAKADR+l
ISZ
AND
L177
TAD
L4600
BAKQ+l
ISZ
BAKQ+!
DCA?
BQSIZE
ISZ
IMORE ROOM?
ONQB
J~P?'
IYES
• -1
TAD
INO, CLOSE THE DOOR
DCA
ONQB+l
JMP7.
ONQB
SETBAK, TAD
ONQ3SW
ICLOSE OFF #IDLE INITIALIZATION
ONQB+l
DCA
CDF
TAD
XSKP
IFIX UP #IDLE
IADD SKIP TO IDLE CALL
DCA?
XI DLE+ 1
BAKQ+l
TAD
IGET ADDRESS OF ROUTINE
ISZ
XIDLE+l
DCA 7.
XIDLE+ 1
ISZ
XIDLE+l
TAD
CIF"CDF
fGET FIELD INSTR.
DCA 7.
XIDLE+l
CIF CDr 10
ONQB+l
JMP
IEXTERNAL REFERENCE
EXTERN #IDLE
#IDLE
XIDLE, ADDR

ADDR

BAKRND

BAKA DR, ADDR

BHADRS

BAKQ,

BQSIZE, -5
CDF CIF'
J;V1P?
13AKRND
BAKRND, 0
REPEAT 6
BAKRND-2
JMP
BHADRS, 0;0;0;0;0

11-5 JOBS

5-13

APPENDIX A
RALF Assembler Permanent Symbol Table

MI'lemonic

Code

FPP Memory Reference Instructions
FADD
FADDM
FDIV
FLDA
FMUL
FMULM
FSTA
FSUB

SETB
SETX
STARTD
STARTE
STARTF
TRAP 3

1000
5000
3000
0000
4000
7000
6000
2000

TRAP 4

TRAPS
TRAP 6

TRAP 7
XTA

lOT'S
FPINT
FPICL
FPCOM
FPHLT
FPST
FPRST
FPIST

6551
6552
6553
6554
6555
6556
6557

AND

0000
1000
2000
3000
4000
5000
6000
7000

Pseudo-Operators

ADDR
BASE
COMMON
COMMZ
DECIMAL
8-Mode Memory Reference Instructions DPCHK
E

TAD
ISZ
DCA
JMS
JMP
lOT
OPR

END
ENTRY
EXTERN
F

FIELDI
IFNDEF
IFNEG
IFNZRO
IFPOS
IFREF
IFZERO
INDEX
LISTOFF
LISTON
OCTAL
ORG
REPEAT
SECT
SECT8
TEXT
ZBLOCK
IFFLAP
IFRALF
IFSW

FPP Special Format Instructions
ADDX
ALN
ATX
FCLA
FEXIT
FNEG
FNOP
FNORM
FPAUSE
JA
JAC
JAL
JEQ
JGE
JGT
JLE

JLT
JNE
JSA
JSR
JXN

0110
0010
0020
0002
0
0003
0040
0004
0001
1030
0007
1070
1000
1010
1060
1020
10-5-0
1040
1120
1130
2000

IFNSlil

A-I

1110
1100
0006
0050
0005
3000
4000
5000
6000
7000
0030

APPENDIX B
ASSEMBLY INSTRUCTIONS
The following sequence of co~~ands may be used to assemble the OS/8
FORTRAN IV system programs. It is assumed that all PAL language
sources reside on DSK. In this example, DTAI is shown as the
target device, however any other device could be used via the
appropriate ASSIGN command. Note that PASS20.SV is produced by
conditional assembly of PASS2.PA and that the "0" in PASS20 is an
oh, not a zero. The initial dot and asterisk characters on every
command line shown are printed by the monitor. All other characters
(except carriage return, in some cases) are typed by the user.
Type CTRL/Z after each of the three system pauses at point ~,
to continue assembly of PASS20. Type ALT MODE to produce the "$"
character •
. ASSIGN DTAI DEV
.R PAL8
*F4.BN,LIST.LS<F4$
.R ABSLDR
*F4$
.SAVE DEV F4=Oi12200S
.R PAL8
*PASS2.BN,LIST.LS<PASS2$
.R ABSLDR
*PASS2$
.SAVE DEV PASS2=Oi5000$
.R PAL8

*PASS20.BN,LIST.LS<TTY:,DSK:PASS2$OVERLY=1
.R ABSLDR
.PASS20$
.SAVE DEV PASS20=Oi7605$
.R PAL8
*PASS3.BN,LIST.LS<PASS3$
.R ABSLDR
*PASS3$
.SAVE DEV PASS3=Oi400$
.R PAL8

*RALF.BN,LIST.LS<:RALF$
.R ABSLDR
*RALF$
.SAVE DEV RALF=Oi200$
.R PAL8
*LOAD.BN, LIST. LS<LOAD$
.R ABSLDR
*LOAD$
.SAVE DEV LOAD=Oi200
.R PAL8
*FRTS.BN,LIST.LS<RTS,RTL$
.R ABSLDR
*FRTS$
.SAVE DEV FRTS=Oi200
.R PAL8
*I..IBRA. BN, LIST. LS <LIBP~~.$

.R ABSLDR
*LIBRA$
.SAVE DEV LIBRA=O;200

B-1

INDEX
Argument passirlg- I
2-1G
Arithmetic expression
analyser,
1-2

Loader symbol table,

Background jobs, 4-1
Binary buffer table 3-8
.
'
B~nary section table, 3-10
Block count sequence number,

4-14

Magic number,
1-6
Mixing code,
2-8
Module,
2-1
Module count table,
3-12
Module descriptor table,
3-11
Off-page references,
2-19
Optimized code,
2-11
Output codes, 1-7
Overlay table,
3-10

COMMON information block 1-7
·
'
C ommun~cation,
2-9
COMMZ sections,
2-12
Compilation,
1-1
Compiler symbol table, 1-2
Device handlers,
4-16
Defice flag handlers,
4-2
Dimension information block,
DSRN table,
4-8

1-5

Entry point, 2-1
EQUIVALENCE information table,
1=7
ESD,
2-1, 2-5, 2-6
ESD correspondence table,
3-8
External symbol,
2-1
External symbol dictionary,
2-1,
2-5, 2-6

/P option,
4-21
Page boundaries,
2-18
PASSl, 1-1
Output,
1-7
Subroutines, 1-10
PASS2,
1-12
Error list, 1-14
Skeleton tables, 1-14
Symbol table,
1-14
Subroutines, 1-15
PASS3, 1-17
PDP-8 code,
2-7
Program loading,
3-9
Program termination,
4-2
Pseudo-ops,
2-7

FIELDI sections,
2-13
Files, 4-13
Formatted I/O, 4-13
FRTS
Calling sequence,
4-4
Core maps,
4-6
Entry points,
4-~
Initialization,
4-14
Page zero,
4-10
Header block,

RALF,
2-1
Expressions,
2-4
Symbol table,
2-5
RALF output file,
2-6
Section,
2-1
Section types,
2-11
Statement number,
1-4
Subroutine calls,
2-9
Subroutine return sequence,
Symbol table,
Compiler, 1-14
Loader,
3-7
RALF,
2-5

3-13

Idle jobs, 4-1
Indirect addressing,
2-7
Interrupts,
Servicing,
4-1, 4-15
Spurious, 4-15
Keyword,

.... ---,--_"1_
L~~era~o,

Termination, program, 4-22
Text,
2-1
TRAP3 and TRAP4,
2-8

1-2

Variable type word,

LIBRA,
5-2
Library I
2-1
Format,
5-1
Line printer handler
,
A
~-~,

~-5

3-1, 3-7

8-mode sections,
4-14
,

Loader f
3-1
Core maps,
3-2 to 3-4
Image file,
3-12
Subroutines,
3-3

X-I

1-3

2-14

2-10

DEC-S8-LFSSA-A-D
OS/8 FORTRAN IV
SOFTWARE SUPPORT MANUAL
READER'S COMMENTS
Digital Equipment Corporation maintains a continuous effort to improve
the quality and usefulness of its publications. To do this effectively
we need user feedback--your critical evaluation of this document.
Did you find errors in this document?

If so, please specify by page.

How can this document be improved?

How does this document compare with other technical documents you
have read?

Job Title

-----------------------------------------Date: --------------------

Name: _________________________________organization: _______________________
Street: _______________________________Department: ____________==-=__________
City:

-----------------------State: ------------Zip or Country-------------

-------------------------------------------------------------Fold lIere------------------------------------------------------------

----------------------------------------------.- Do Not Tear· Fold lIere and Staple -----------------------------------------------

FIRST CLASS
PERMIT NO. 33
MAYNARD, MASS.
BUSINESS REPLY MAIL
NO POSTAGE STAMP NECESSARY IF MAILED IN THE UNITED STATES

Postage will be paid by:

Digital Equipment Corporation
Software Information Service
Software Engineering and Services
Maynard~ Massachusetts 01754