Digital PDFs

DEC-S8-LFSSA-A-D

December 1973

110 pages

Original

3.8MB

Document:	OS8 Fortran IV Software Support Manual 197306
Order Number:	DEC-S8-LFSSA-A-D
Revision:
Pages:	110
Original Filename:	https://svn.so-much-stuff.com/svn/trunk/pdp8/src/dec/dec-s8-lfssa/dec-s8-lfssa-a-d.pdf

OCR Text

sor:tware
support manual

digital equipment corporation

DEC-S8-LFSSA-A-D

OS/8 FORTRAN IV
SOFTWARE SUPPORT MANUAL

For additional copies, order No. DEC~8-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

11/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

CHAPTER 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 PASSI to RALF assembly language making extensive 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, PASSI 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 arithmetic statement function) the switch 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 t:ell 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

(NOTE:

A detailed description of each type of entry follows.

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.

...
J II I
...

POINTER
TYPE

DIMENSION/EQUIVALENCE

NAME 2-3

NAME 4-5

NAME 6

TYPE WORD FORMAT

o
Co

1
M

U
I

Ex
V

L
I
T

BIT
~

variable is in common.

variable is dimensioned.

External symbol or subroutine/function name.

Symbol is the name of an arithmetic statement function.

Variable is an equivalence slave.

Variable is explicitly typed.

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

same program will cause one entry in each of the integer and
real literal lists.
POINTER
TYPE
EXPONENT
MANTISSA 0-11
MANTISSA 12-23
4.

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

POINTER
TYPE
REAL EXPONENT
REAL MANTISSA 0-11
REAL MANTISSA 12-23
IMAGINARY EXPONENT
IMAGINARY MANTISSA 0-11
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

IIIIII

TYPE
EXPONENT
MANTISSA 0-11
MANTISSA 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

d.
J

where d. is the jth dimension and n is the nmnber 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 INFORMATION 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
The fourth word is

variable from the EQUIVALENCE statement.
the linearized subscript of the

s~ave

variable.

POINTER TO DIMENSIONS
POINTER TO MASTER

MASTER SUBSCRIPT

SSM

SLAVE SUBSCRIPT

SSM

COMMON INFORMATION BLOCK - If a symbol is defined as the name
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

NUMBER 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 PASSl) 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.

FMTRDI

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

1-8

RCLOSE

Compile a READ-close.

DARDl

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

BINWRl
FMTWRI
WCLOSE
DAWRl

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 ni take the
previous n stack entri~~ as subscripts (or
arguments) and the N+l
entry from the top as
the array (or function) namei 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
rewind.

STOROP

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

ENDOPR

Compile a RETURN 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.

ARTHIF

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 listi 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 PASS1 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 PASSI
output file.

COMARP

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

BACKI

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 PASSI 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 off 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

1:he 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.
rnain 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 RALF code.
Example:
The statement: A=B+C*D
would produce the following PASSI output:
(assuming A,B,C,D are REAL)
1)

PUSH
+A

PUSH
+B

PUSH
+C

PUSH
+D

MUL

ADD

STOROP

EOLCOD

(symbol table address of A)

1-12

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,ACi
Memory,MemorYi 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 crea'tes 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 t:o

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:
1)

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 ~ouble 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:
1)

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:

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 ARGl, TYPEl,
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 PASSl 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 "#".

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 u TYPEI,
and BASEl.

GARGS

Pop the top two stack entries into ARGI, TYPEI,
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 12-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,

When 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), 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 assembler.
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

An address within a section which is named and defined
to be global, so that it may be used 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 t:here 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
U8R, 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 initializa'tion 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 in a REPEAT line and the

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 128th 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 sign, 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 sole 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, and depend~ng 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 usually a two-word 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
CDF SWAP

/Illegal
/Under
/RALF

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
TAD A
DCA B

TAD% A
DCA% B

PAGE ZERO
DIRECT
INDIRECT
TADZ A
DCAZ 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%Z".

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

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

ACDF
.+1

TAD
RTL
RAL
TAD
DCA

KSUB
CLL

/Set DF to current
/IF for return
/CDF X
/Make a CIF from
/Field bits

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% RETURN+l
2-8

RETURN,

EXTERN #RETRN
ADDR #RETRN

Communication between FPP and a-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 a-mode routine:
EXTERN SUB
EXTERN SUBIN
EXTERN SUBOUT

FLDA X
FSTA SUBIN
TRAP 4 SUB
FLDA SUBOUT
FSTA Y

IArg for SUB
ICall SUB
IGet result

If the a-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 a-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 a-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
Jj

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 SUB
JSR
SUB
JA
BYARG
JA
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
JA

SUB
#ST

BASE

2-10

#ST, STARTD
FLDA
FSTA
FLDA
SETX
SETB
BASE
INDEX
FSTA

XSUB
BSUB
BSUB
XSUB
BSUBX

STARTF
JA

GOBAK

30
GOBAK

ISo only 2 words
/Will 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 not 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:
FLDA 0
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

types of section are forced to begin and end on page boundaries and to
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 0 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 a-mode code in different modules to share pa.ge 0, provided that the modules do not destroy each other's page 0 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
P2,
KSUBAl,
KSUBA2,

COMMZ SHARE
1
2
SUBAl
SUBA2

LASTA,

-1

FIELDI

P.l,

/Should not go over
/20 locations

TADZ PI
JMSZ% KSUBAl
/Module B
COMMZ SHARE
ORG .+20
P3,

P4,

3
4

KSUBB,

SUBB

L,ASTB
FIELDI

/ORG past module A's
/Page 0

-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
2
3

1
2
SUBAI
SUBA2

1 0017
1 0020
21
22

-1

/LASTA

3
4
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 COMMZ SHARE may be
included in module B.

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 I COMMZ section name.

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

The second allows

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

Two FIELDI 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,

i1: 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 FIELDI 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 #OISP appears in the code.

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

Special purpose POP-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:
#IOLE, JMP

.+4

COF
JMS

CIF
I
.-2

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

The location #IOLE must be changed to a SKP (74l0).
set to the address of the routine to be called.
to a COF CIF to the field of the routine.

#IOLE+2 must be set

This setup can be done in a

routine that is called at the beginning of MAIN.

For example:

CALL SETIOL
where SETIOL is a routine such as:
SECT8 SETIOL
#RET

/Must be an 8-mode section

TEXT +SETIOL+

/Traceback information

SXR,
BP,
XR,

SETX XR
SETB BP
0.0
0.0

ORG 10*3+BP

2-15

#IOLE+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 IDPTR
TAD JOB
CLL RTL
RAL
TAD SFIELD
ISZ IDPTR
DCA% IDPTR
CDF CIF
JMP% SET8

SCD:F,
SFIEL,
IDPTR,
S7410,

/Return to main

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

IDLAD,
JOB,

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

EXTERN #IDLE
AD DR #IDLE
ADDR DOlT

/Address of #IDLE
/CDF goes here
!SKP
/Store at #IDLE
/Address of IDLE top routine
/Store a #IDLE+1
/Fie1d of routine
/Position
/Store at #IDLE+2
/Set to field 0
/Return to instruction
/Fo1lowing II TRAP 4 SET8 11

6201
6203

/15 bit address of IDLE
/15 bit address of IDLE
/Routine IIDOlT Ii
/CDF
/CDF CIF

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 argument, an argument 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

EXTMPI

/A value of 0 is illegal

EXTMP2
EXAMER

/The value in EXTMPI 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 FORTRAN 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 AMOD 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 AMOD(X,Y) .
2-17

When called from FORTRAN, the

I
I
I
I
I
I

A MOD

IS UBRO UTI NE
SECT
ENTRY
JA
TEXT
AMODXR, SETX
SETB
BPAMOD, F 0.0
XRAMOD, F 0.0
AMO DX,
F' 0 • 0
ORG
FNOP
JA

AMOD(X,Y)
AMOD
MOD
IAMOD
+AMOD +
XRAMOD
BPAMOD

10*3+BPAMOD

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

AMODXR

AMDRTN, JA
•
IEXIT
EXTERN lARGER
IPRINT AN ERROR MESSAGE
AMODER, TRAP4
lARGER
IEXIT WITH FAC:0
FCLA
JA
AMDRTN
ISTAY ON CALLER~S BASE PG
BASE
"
ILONG ENOUGH TO GET RETURN ADDRESS
ISTART OF INTEGER ROUTINE SAME AS
MOD,
ISTART OF REAL NU~. ROUTINE
IAMOD, STARTD
IGET RETU~N JUMP
FLDA
10*3
ISAVE IN THIS PROGRAM
FSTA
AMDRTN
o
IGET POINTER TO PASSED ARG
FLDA
SETX
XRAMO::>
IASSIGN MOD'S INDEX REGS
SETB
8PAMOD
lAND ITS BASE PAGE
BASE
BPAMO~
1, 1
LDX
FSTA
BPAMOD
FLDA7.
BPAMOD,1
IADDR OF X
FSTA
AMODX
FLDA7.
BPAMOD,I+
IADDR OF Y
FSTA
BPAMOD
STARTF'
FLDA 7.
BPAMOD
IGET Y
JEQ
IY:0 IS ERROR
AMODER
JGT
.+3
FNEG
lABS VALUE
FSTA
BPAMOD
FLDA7.
AMODX
IGET X
JGT
.+5
lABS VALUE
FNEG
INOTE SIGN
LDX
",1
FSTA
AMODX
ISAV IN A TEMPORARY
FDIV
BPAMOD
IDIVIDE BY Y
JAL
AMODER
ITOO BIG.
o
ALN
I F' I X I T UP NO IN •
FNORM
FMUL
BPAMOD
IMULITPLY IT.
FNEG
INEGATE IT.
FADD
AMODX
lAND ADD IN X.
JXN
AM,l
ICHECK SIGN
FNEG
JA
AM.
AMDRTN
IOONE
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 FIELDl sections.

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

FIELDl 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

SECTS PARTA
SECTS PARTB
SECTS 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 FIELDl 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

TAD
DCA%

VAR2
AVARl+l

00156
00157

0000 AVARl,ADDR VARI
0322

/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
/Rotate to bits 6-8
/Add a CDF
/Deposit in line
/Execute 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 by

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 12-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
O) 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 (!), 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
MODE8

ATX

MODE8

/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

MODE 8 ,

For example,

/PDP-8 routine
MODE 8

/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 concludes 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 Conunand Decoder

02000

Loader Pass 1 and
Pass 2

04600

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

,_ _ _ _ -.-

FIELD ~

.. _ _ _ -r ••__ · • M •• ,

-----

06600
Unused
07600
10000

---------.
OS/8 Field ~ resident
OS/8 User Service Routine
FIELD 1

-~-.------

12000

Symbol table, loader map
titles

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 eORDSW checks for

the presence of /U, /e 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)
FIELD ~

00000

Pass 1 and Pass 2
utility routines

01400

Symbol map printer

02000

Pass 2

03200

Pass 1 symbol collection

04000

Inter-pass code allocates
storage, builds and writes
Loader Image Header Block.

04600

07200

Library catalog loads
here in 8K.
Unused in
12K or more.
Input device handlers

07600

OS/8 Field ~ resident

10000

ESD table

FIELD 1

11400
12000

Symbol table

15400

Overlay length table

16000

Module count and module
tables (MCTTBL, MODTBL)

17200

Loader header

17400

ESD reference page

17600

OS/8 Field 1 resident

20000

Library catalog loads here
in 12K or more.

25000

OS/8 BATCH processor if
12K or more and BATCH
is running

FIELD 2

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

JMS CORMOV
CDF FROMFIELD
FROMADDR - 1
CDF TOFIELD
TOADDR - 1
- 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

107200

I/O device handlers

~.---".----"

'--~

107600

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

FIELD 1

17600

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 fA

symbol map
output buffer

FIELD 2

Unused

30000

RALF module text loads
here if >12K

chapter.

The subroutines are presented in approximately 1:he order

FIELD 3

that they occur in the source listing.
SETBPT

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

TTYHAN

Subroutine to unpack and print a TEXT message on the
console terminal. TTYHAN is called by:
eOF CURRENT
elF 0
JMS TTYHAN
eOF MSGFIELO
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.
sequence is:
TAD (ACARG
CDF CURRENT
CIF 0
JMS IOHAN
ADDR
ARGI
ARG2
ARG3

The calling

/Optional

where ARGl, ARG2 and ARG3 are standard OS/8 device
handler arguments and ADDR points to a three-word
block in field 1 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 symbol is not found, it is inserted into the
loader symbol table and GPTR is set to point to the
word following the symbol name.

SYMMAP

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 I 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)
Each entry is 7 words long, and provides the name and

user entries.

The table is organized in buckets

definition of a symbol.

according

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

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
symbol 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:

.
Pointer to next symbol in
bucket (zero if none) •

I-bit trap
vector flag d uring
pass 1.
Erro r
flag during p ass 2.

WORO 1

WORO 2

WORD 3

3-bit

4-bit

level

overlay

4-bit type code

/~ -- undefined
entry point

2 - extern
3 - common sect
9-bit pointer to
4 - program sect
parent symbol during Field 5 - multiple entry point
pass 1 (zero if none). bits 6 - mUltiple sect
Trap vector displace7 - SECT8 sect
ment during pass 2.
1 O-CCM4Z
1 l-FIEIDI
ADDRESS
1 2 to 17- undefined
(Length during pass 1)

3-7

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 nth 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.
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.

Buffer
field
bits

WORD 1

WORD 2

WORD 3

Unused

WORD 4

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

NO. OF

AVAIL

BUFFERS

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

2
4
5
7

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

3-9

BINARY SECTION TABLE

~rhe

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
.~ntries.

Each entry relates the core origin of one of the eight

overlay levels to that level's position in the loader image file.
'rhe 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)

~rhe

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 MA
__I_N____________~
LEVEL 1 OVERLAY 1
r

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

r----------./
HIGH-order bits
of length

)--~u 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 in the 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 I, 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 MAIN module #1

{

OS/8 I/O unit #

- -

File length (positive)

Level MAIN module #2
Level MAIN module #3

...~
Level MAIN module n

Starting block #

- .....

-v-

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

-----

Level 1 Overlay 1 module #n

...

Level 1 Overlay 2 module #1

-.
-~--rLevel m Overlay n module #p

1-------

Library module #1
Library module #2

---

.....

MODTBL format

3-11

MODTBL format of
individual entry (3 words)

MODULE COUNT TABLE (MCTTBL)

The module count table begins at location 16000 and contains room for
122 (decimal) l-word entries that give the (two's complemen't) module
The table format is:

count for each overlay level.

MCTTBL
LEVEL MAIN
l-word ENTRIES
I-~-I

--l

RL_A_Y_~_-~

I--_L_E_VE_L_l_OVE
__
LEVEL 1 OVERLAY
LEVEL 1 OVERLAY

.-'

~----------------LEVEL 1 OVERLAY n
~
r------------------------

LEVEL 2 OVERLAY 1
LEVEL 2 OVERLAY 2

,------------------------LEVEL : OVERLAY
~I
--....--~

LEVEL 3 OVERLAY 1

---LEVEL m OVERLAY n
~

~-------------------------

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

3-12

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

LOCATION

CONTENTS

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:

Unused until SWAP time.
be positive or zero.
Load address ~ Page
bits

Bits 4-5
unused

Field
bits

Must

Bits 9-11
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 user's 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 IONQI
EXTERN # DISMS
FIELDl GETCH
0
ISZ FIRST
JMP NOTFST
JMS7. ONQI+l
KSFl
ADDR KSF5UB
TAD D15M I S+ 1
DCA HNGLOC
NOTFST, IOF
TAD INCHR
SZA CLA
JMP GOTl
CIF' 0
JMS7. HANG+l
HNGLOC, 0
GOTI,

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

KSFSUB, 0
KRBI
DCA INCHR
CDF CIF 0
JMP7. DISMIS+I
INCHR,
ONQI,
HANG,
DISMIS,
FIRST,

IJMS GETCH GETS A CHAR
IGETCH RUNS IN FIELD 1 ONLY

15ET UP TO CALL HANG

INO CHAR READY: HANG

IHANG RETURNS WI IOF

IINTERRUPT ROUTINE
ICALLED AS SUBROUTINE

IRETURN TO SYSTEM LOCATION
ICONTAINING "JMP DISMIS"

0
ADDR 10NGI
A~DR #HANG
ADDR # DI5MS
-1

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, changing only the
section, entry, base page, index register and return location names.

4-3

FR'rs CALLING SEQUENCE

/Section name. Your module may
/require another section pseudo-op
/such as FIELDI or SECT8.
JA #EXSRT
/Jump to start of subroutine
fUse # 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
SECT EXAMPL

EXAMXR,
lBPEXAM,
XREXAM,
EXTMPl,
EXTMP2,
EXTMP3,

EXMRTN,
#EXSRT,

STARTF
FLDA% EXTMPI

/Startthree-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 #UE

/Produces USER ERROR error message.

#ARGER or
#ARGERR

TRAP4 #ARGER

/Produces BAD ARG error message.

#READO

TRAP 3 # RE.ADO
JA UNITNO
JA FORMAT

/Initializes
/formatted
/read operation.

#WRITO

TRAP 3 #WRITO
JA UNITNO
JA FORMAT

/Initializes
/formatted
/write operation.

#RUO

TRAP3 #RUO
JA UNITNO

/Initializes unformatted
/read operation.

#WUO

TRAP3 #WUO
JA UNITNO

/lnitializes 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

TRAP3 #RENDO

/Terminates a read/write operation.

#ENDF

FLDA UNITNO
TRAP3 #ENDF
or TRAP3 #REW
or TRAP3 #BAK

#REW
#BAK
#DEF

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

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 ini tialization. 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

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

OS/8 User Service Routine

~~--~-~

4-6

12000

-- --

r--.r-----...,- FRTS loader tables, IONTBL

12200
12400

program start-up 1

12600

initialize and
conf igure system

13000

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

13400

Utility and error routines,
error messages

14000
15600

FPP start-up and trap routines Locations 14000 to 16777 are used
save lower field 0 during loading
16000 Band 0 format I/O
of device handlers and file
r-_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _--Ispecifications
16600 EAE Floating-point package
~----------------Ito

17400

Termination routine
Locations 17400 to 17777 are
________________---Iwritten on SYS block 37 before
OS/8 field 1 resident
program load and restored on
termination

17600

~------------------------------

#INT

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

eDF elF 0
JMS I .-2

/Replace with SKP
/Replace with 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

'rhe 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 developlnent 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

Character
position

Value of
CHRCTR

Next value
of CHRPTR

Next value
of CHRCTR

addressed by

-2

CHRPTR + 1

-1

input operation an d
CHRPTR mod 256=0

CHRPTR
-2

Refresh buffer if

Bits 4-11 of word
-3

Special
Conditions

-1

-3

CHRPTR

none

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

Dump buffer if
output operation an d

CHRPTR-l

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:

That is, block

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.

Bit

When any active unit is selected for an I/O operation, the DSRN table
entry for that unit is moved into 9 words 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-VB

PAGE 3

IPAGE ZERO FOR FORTRAN IV RTS
00000
0'~001

00002
00003
00004
00005
00006
00007
0001a
013011

00012
00013
00016
00017
013020

00021
00022

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

0000

0000
0000

0000

IINTERRUPT STUFF

JMP I
.+1
INTRPT
LPGET, LPBUFR
TOCHR, o
KBDCHR, o
POCHR, o
RDRCHR, o
FMTPXR, o
INBUFR-l
INXR,
o
XR,
XR 1 ,
o

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

*16

VEOFSW, 0
o
o
T,
o
DFLG,
o
INST,

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

IIOH PAGE ZERO LOCATIONS
00023
00024
013025

00026
00027
00030

0000
0000
0000
0000
0000

0000

RWFLAG,
FMTTYP,
EOLSw,
N,
W,
D,

0
0
0
0
0

00031
00032
00033

0000
0000
5431

DATCDF, 0
DATAF, 0
JMP I

00034

5013
0000
5000

ERR,
FATAL,
MCDF,

001335

00036

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

DATCDF

ERROR

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

MAKCDF

IF?P PARAMETER TABLE LOCATIONS:
0,0037

00046

0000
5313
0000
0000
0000
0000
0000
0000

00047
00050
00051

0000

00040
00041

00042
00043
00044
00045

0000
0000

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

IVARIOUS FIELD BITS FOR FPP
IFPP PROGRAM COUNTER
IF?P 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

PALS-VS

PAGE 4

IFLOATING POINT PACKAGE LOCATIONS
00052
00053
00054
00055
00056
00057

0000

0000
0000
0000
0000

AC0,

IFLOATING AC OVERFLOW WORD
10PERAND OVFLOW WORD

ACt,
AC2,

OPX,
OPH,
OPL,

1*** FLOATING OPERAND REGISTER ***

IRTS 1/0 SYSTEM LOCATIONS
00060
00061
00062
00063
00064
00065
00066
00067
00070
00071
00072
00073
00074
00075
00076

0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0320
0000
6001

FMTBYT, o
o
IFLG,
o
GFLG,
EFLG,
o
00,
o
SCALE,
PFACT, o
PFACTX, o
INESW, o
CHCH,
o
FMTNUM, o
CTCINH, o
PTTY,
TTY

IFORMAT BYTE POINTER
II FOEIYJAT FLAG
IG FORMAT FLAG
IE FORMAT FLAG - SOMETIMES ON FOR

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

0000
0000
0000

HAND,
"
HCODEW, "
BADFLD, 0
CHRPTR, 0
CHRCTR, 0
STBLK, "
RELBLK, 0
TOTBLK, '"
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
IFILE FLAGS:
IBIT 0 - "HAS BEEN WRITTEN" FLAG
IBITS 1-2 - FORMATTED/UNFORMATTED
IBIT 11 - "END-FILED" FLAG

00110
00111
00112

0000
7402
5510

BUFFLD, 0
BUFCDF, HLT
JMP I

IROUTINE TO SET OF TO BUFFER FIELD

00113
00114
00115

0000
0000,
0000
0200

rGPBF, 0
BIOPTR, 0
FEXIT
PAGE

00077
00100
00101
00102
00103
00104
00105
00106
00107

0000
0000
0000
0000
0000

0000

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

FTEMP2, I SZ
.+3
CDF CIF 10
JMP I
.+1
VDATE, RTSLDR

IALSO USED AS 1/0 F.P. TEMPORARY
IUSED TO STORE OS/8 DATE

IRTS ENTRY POINTS - "VERSION INDEPENDENT"
00204

5111

VUERR,

00205
00206
00201
00210
00211
00212
00213
00214
00215

4434
2023
5634
5776
5175
5174
5113
1330
5112
1330
5711
1330
5110
5161
3000
1311

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

100216

00211
00220
00221
00222
00223
00224
00225
00226
00221
00230
00231
00232
00233

0000

0000
5166
0000
6203
4630
5221

JMP I

(USRERR IUSER ERROR
1** LOADER MUST DEFINE lARGER AS
ERR
ILIBRARY ARGUMENT ERROR
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
IOVERLAY PROCESSOR
CALXIT I"STOP" ROUTINE - ENTERED IN FPP

V80R12,0;0
VBACKG, JMP I

10; 1 IF CPU IS A PDP-12

(NULLJB IBACKGROUND JOB DISPATCHER

CDF CIF 0
JMS I
.-2
JMP
VBACKG

IUSED BY ROUTINE "ONQB" IN LIBRARY

IIOH GET VARIABLE ROUTINE.
ITHIS ROUTINE MAKES THE FORMATTED 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
5517

GETLMN, 0
VRETRN, JMP I

[RETURN

4-12

All FORTRAN IV mass storage I/O is performed in terms of 08/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 FORMAT statement associated with the READ or
WRITE.

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

two 12-bit words as follows:
MASS STORAGE

CORE

WORD 3
bits 0-3

WORD 1

WORD 3
bits 4-7

WORD 2

WORD 1
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 FORTRAN 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 conten1: o:f FRTS
location 12623 from 7413 to 7200.
FRTS is started.

These changes must be made before

The OS/8 monitor GET and ODT conunands pl."ovide 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.

The entire

07400 page is included in the line printer ring buffer.

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 NOP 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 NOPs occupying the

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

Any of these NOP 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 limitations, it is not possible to add internal I/O
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

IFOHTRAN 4 RUNTIME SYSTEM - R.L

PAGE 6

PAL8-V8

IINTERRUPT DRIVEN 1/0 HANDLERS
00236
00237

1211211210

LPT,

IRING-BUFFERED - LP08 OR LS8E
IJUST IN CASE

0121263
121121264
0121265
0121266

601211

5636

[311
AND
LPTSNA, SNA
(IOERR
JMP I
10F
DCA I
LPPUT
TAD
LPGET
CIA
TAD
LPPUT
SZA CLA
JMP
.+3
TAD I
LPPUT
LLS
CLA lAC
LIE
TAD
LPPUT
DCA
LPPUT
LPPUT
TAD I
SPA
JMP
.-3
SZA CLA
JMS I
(HANG
LPUHNG
ION
JMP I
LPT

00261

5165

LPPUT,

LPBUFR

1211210121

PTP,

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

0121240

00241
00242
00243
00244
0121245
00246
00241
00250
00251
00252
00253
00254
121121255
0121256
1210251
0121260

00261
00262

0121270

1210211

0121212

121121273
00274
0121275
00276

121116

7450
5165
601212

3661
11211213
7041
1261
7640
5253
1667
6666
1201
6665
1267
3261
1667
751121
5256
7640
4164
0436

7450
5165
3236
6002
11211216

0121301
0031212

7640
4764
0502
1236
6026

00303
1210304

312106
601211

0121211

012130121

121031215

567121

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&7012J0
TTUHNG&70eJeJ
KBUHNG&1000
RDUHNG&7eJ00
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,

0
SZA CLA
JMP I
10F'
RFC
JMS I
RDUHNG
TAD
ION
JMP I

ICRUDE READER HANDLER
(IOERR

1005
7650
4764
0465
1005
3236

00353
00354
00355
00356
00357
00360
00361
00362

6554
2353
5354
6552
7430
5763
6032
4434

3'105

1236
5340

ISTART READER

(HANG
RDRCHR

IHANG UNTIL COMPLETE
IGET CHARACTER

PTR

IRE TURN

0
IOF
SNA

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

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

IFORTRAN 4 RUNTIME SYSTEM .. R.L
00342
00343
00344
00345
00346
00347
00350
00351
00352

KBD,

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

PAL8-V8

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

KILF'PP, FPHLT
ISZ
JMP
F'PICL
SZL
JIYJP I
KCC
CTLBER, JMS I

10UTPUT ILLEGAL TO PTR

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 F??
IfC OR fB1
IfC - HIYO SILVER, AWAY!
ICLEAR KBD FLAG ON f8
1*** THIS MAY 8E DANGEROUSl

4-17

IF'ORTRA N 4 RUNTIME SYSTEM - R.L

PAL8-VB

PAGE 9

IINTERRUPT SERVICE ROUTINES
00400
00401
00402
02)403

3322
7010
3323
5207

00404
00405
00406

0000
6203
4604

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

00407
00410
00411

6551
5215
5314

FPINT
J.'1P
FPUHNG, JMP

LPTEST
DISMIS

00412
00413
02)414

5314
5314
5314

VDISMS, JMP
JMP
JMP

DIS MIS
DISMIS
DISMIS

00415
00416
0:!J417
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
LPTLCF, LCF
LPGET
TAD I
SNA CLA
J;tIPDIS, JMP
DISMIS
DCA I
LPGET
LPGET
ISZ
TAD I
LPGET
SPA
DCA
LPGET
SNA
LPGET
TAD I
SZA
LLS
CLA
LSF
DISiVJIS
LPUHNG, JIYJP
Jr~p
LPTLCF

00440
00441
00442
00443
00444
00445
00446
00447
00450
0121451

6041
5252
6042
1004
7540
6046
7740
7130
3004
5314

NOTLPT, TSF
NOTITY
JMP
TCF
TOCHR
TAD
SMA SZA
TLS
SI'1A SZA CLA
STL RAR
TOCHR
DCA
DISMIS
TTUHNG, JfY1P

4-18

ICHECK FOR FPP DONE
IALWAYS GOES TO RESTRT

IFOR USE BY USERS

IC LEAR FLA G
ICHECK FOR SPURIOUS INTERRUPT
IGO AWAY IF SO
IZERa 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
INa - MAYBE RESTART PROGRAM
IYES - LOOP
ICHECK TTY
ICLEAR FLAG
IGET TTY STATUS
IIF THERE IS A CHARACTER WAITING,
10UTPUT IT.
ICHANGE "WAITING" TO BUSY" ,
I"BUSY" TO "IDLE".
.f

IFORTRAN 4 RUNTIME SYSTEM - R.L

PALS-V8

PAGE

If2J

IKBD AND PTP INTERRUPTS
00452
00453
00454
00455
00456
00451
00460
00461
00462
00463
00464
00465

6031
5216
1115
6034
3005
1005
1317
7110
7650
5266
6032
5314

NOTTTY, KSF
JMP
NOTKBD
[200
TAD
KRS
KBDCHR
DCA
KBDCHR
TAD
TAD
(-202
CLL RAR
SNA CLA
JMP
CTCCTS
KCC
DISMIS
KBUHNG, Jf1P

00466
00467
00410
00411
00412
00413
00474
00415

1073
1650
5366
1323
7104
1322
6244
5400

CTCCTB, TAD
CTCINH
SNA CLA
JMP
NOTINH
TAD
INTLNK
CLL RAL
TAD
INTAC
RMf"
JMP I
0

00476
00471
00500
00501
00502

6021
5303
6022
3006
5314

NOTKBD, PSF
JMP
PCF
DCA
PPUHNG, JMP

00503
00504
00505
00506
00507
00510

6011
5311
1175
6012
3001
5314

NOTPTP, RSF
JIYlP
TAD
RRB
DCA
RDUHNG, JMP

00511
00512
00513
00514
00515
00516
00511
00520
00521

6663
7410
6667
1323
7104
1322
6244
6001
5400

LPTERR, LSE
SKP
LIF
INTLNK
DISMIS, TAD
CLL RAL
TAD
INTAC
RMF
ION
Jf1P I
0

00522
00523

0000
0000

INTAC, 0
INTLNK, 0

IUSE KRS TO FORCE PARITY BIT
lAND ALSO SO THAT tC WILL STILL
ICHECK FOR tC OR tB
IYUP - TAKE SOME DRASTIC ACTION
IDATA CHARACTER - CLEAR FLAG

IARE WE IN A HANDLER?
INO
IYES - RETURN WITH INTERRUPTS OFF
ITRUST IN GOD AND RTS

NOTPTP
POCHR
DISMIS
LPTERR
[200
RDRCHR
DISMIS

4-19

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

IGET RDR CHAR

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

IFORTRAN 4 RUNTIME SYSTEM - R.L

PALS-V8

PAGE 11

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

0000
1124
3311
6214
1332
3364
6203
1316
3111
1313
1104
1312
6202
6201
6001
5174

HANG,

COME HERE WHEN THE HANG CONDITION HAS GONE AWAY

IALWAYS CALLED WITH INTERRUPTS OFFl
HANG
IGET POINTER TO UNHANGING LOCATION
TAD I
DCA
UNHANG
RDF
IGET FIELD CALLED FROM
HCIDF0
TAD
DCA
HNGCDF ISAVE FOR RETURN
HCIDF0, CDF CIF o
(JMP REST~T
ICHANGE THE "JMP DISMIS"
TAD
DCA I
UNHANG ITO A "JMP RESTRT"
TAD
BACKLK
CLL RAL
BACKAC IS£T UP BACKGROUND AC AND LINK
TAD
BAKCIF, CIF 0
BAKCDF, CDF 0
ION
Jr~p I
BACKPC IINITIATE BACKGROUND

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

1222
3771
1322
3372
1323
3373
1000
3374
6234
0114
1332
3340
6234
4436
3341
2324
1402
5124

RESTRT, TAD
DCA I
TAD
DCA

00566
00567
00510

1222
3111
5715

NOTINH, TAD
DCA I

00511
00572

0000
0000
0000
0221
0524

UNHANG, o
BACKAC, o
BACKLK, o
BACKPC, VBACKG
VHANG= HANG
IFNZRO

0~513

00514
00515
00576
00577

0353
5344
1516
0600

TAD

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

Jt1P I

Jf1PDI S
UNHANG
INTAC
BACKAC
INTLNK
BACKLK
o
BACKPC

IRESTORE THE UNHANG LOCATION
ISUSPEND THE BACKGROUND

[10

HCIDF0
BAKCIF
MCDF
BAKCDF
HANG

I*K* OK SINCE BACKGROUND DOESN'T

HANG

IINTERRUPTS ARE OFF - RETURN

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

VHA NG -0 52 4

PAGE

4-20

<~~

CHANGE LOADERl>

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 desirable 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:
1.

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 /p option to halt. Any fatal error 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.
2. CTRL/C is recognized, or the CPU is halted and re-started in
07600.
3. A STOP, CALL EXIT, or (under RALF) JSR #EXIT sta1:ement 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
6600

FPPKG=

PAL8-V8

PAGE 78

IFOR EAE OVERLAY

•

123-8IT FLOATING PT INTEHPRETER

IW.J. CLOGHER, MODIFIED BY R.LARY FOR FORTRAN

06600
06616

0000
7160

LPBUF2, ZBLOCK
LPBUF3

06617
06620
06621
06622
06623
06624

0000
7240
1044
3044
4542
5617

ALIBMP, 0
STA
TAD
DCA

06625
06626
06627
06630
06631
06632
06633
06634
06635
06636
06637
06640
06641
06642
06643
06644
06645
06646
06647
06650
06651
06652
06653
06654
06655
06656
06657
06660
06661
06662
06663
06664

4777
741~

4776
4304
1044
3044
3304
3054
1045
7650
3044
4334
1056
3057
4334
1054
3046
1304
3045
1045
7004
1710
4211
1053
1710
2046
5265
2045
1045
1510
5775
1200

I*K* UTILITY SUBROUTINE
ACX
ACX

JIw'JS I
JMP I

[ J~L 1

ALIBMP

IFLOATING MULTIPLY-DOES 2 24X12 BIT MULTIPLIES
DDMPY, JMS I
(DARGET
SKP
FF'MPY, Jlv)S I
(ARGET IGET OPERAND
JMS
MOSET
ISET UP FOR MPY-OPX IN AC ON RETN.
TAD
ACX
100 EXPONENT ADDITION
DCA
ACX
ISTORE FINAL EXPONENT
[~DSET
DCA
IZERO TEM STORAGE FOR MPY ROUTINE
AC2
DCA
TAD
ACH
lIS FAe=0?
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

MP24

TAD
DCA
TAD
DCA
TAD
RAt.
SPA
JMS
TAD

AC2
ACL
MOSET
ACH
ACH

SPA

CLA

ISZ
JMP

ISZ
TAD
SPA
JMP I

CLA

CLA
ALI aMP
ACI
ACL
MDONE
ACH
ACH
(SHR1

4-23

ISTORE RESULT BACK IN FAC
ILOW ORDER
IHIGH ORDER
100 WE NEED TO NORMALIZE?

IYES-DO IT FAST
ICHECK OVERFLOW WORD
IHIGH BIT ON - ROUND RESULT

ILOW ORDER OVERFLOWED - INCREMENT
ICHECK FOR OVERFLOW TO 4000 0000
IWE HANDLE A SIMILIAR CASE IN

IFORTRAN 4 RUNTIME SYSTEM - R.L
~'6665

06G66
06667
06670
06671
06672
06673
06674
06675
06676
06677
06700
06701
k~67 02
06703

3053
2333
7410
4543
1045
7650
3044
1021
7740
1044
7450
5476
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 79

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

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.
~'6704

06705
06706
'~6707
'~6710
'~67 11

06712
06713
06714
06715
06716
1~67 17
06720
06721
06722
06723
06724
06725
06726
06727
06730
06731
06732
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

MDSET,

LEV,
MSIGN,

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

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
1216735
1216736
1216737
1216740
1216741
1216742
1216743
06744
06745
1216746
06747
1216750
1216751
1216752
1216753
1216154
1216155
06756
1216751
121616121
1216161
1216162
~'6163

1216164
1216765
1216166
1216161
06710
1216111
1216713
06114
06115
1216116
06111

121121121121
1313
312155
112151
1440
5345
3053
5134
112151
11211121
312151
142121
5356
1054
112146
312154
112124
112145
131214
112110
331214
112154
71211121
312154
112153
71211121
312153
212155
5344
5134
7164
121213
711121
6514
646121
7121121121

MP24,

MPLP,
MPlP 1 ,

MPlP2,

(-14
TAD
DCA
OPX
TAD
OPL
SZA
JMP
MPLP 1
ACI
DCA
MP24
JMP I
TAD
OPL
RAR
DCA
OPL
SNL
JMP
MPLP2
AC2
TAD
ACL
TAD
DCA
AC2
CML RAL
ACH
TAD
MDSET
TAD
RAR
[rIDSET
DCA
AC2
TAD
RAR
AC2
DCA
ACI
TAD
RAR
ACI
DCA
ISZ
OPX
JMP
MPLP
JMP I
MP24

ISET UP 12 BIT COUNTER
lIS MULTIPlIER=r2J?

INO-GO ON
IYES-INSURE RESULT=r2J
IRETURN
ISHIFT A BIT OUT OF LOW ORDER
10F MULTIPLIER AND INTO lINK
IWAS I TAl?
INO - 121 - 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

10VERFlOW TO ACI

IDONE ALL 12 MULTIPLIER BITS?
INO-GO ON
IYES-RETURN

PAGE

IFORTRAN 4 RUNTIME SYSTEM - R.L

PAL8-V8

PAGE 82

IDIVIDE-BY-ZERO ROUTINE - MUST BE AT BEGINNING OF' PAGE
12110121121
071211211
12111211212
12111211213
121101214
12171211215

212135
4434
120121
3044
1332
5325

DBAD,

ISZ
JMS I
TAD
DCA
AC2000
JMP

FATAL
ERR
DBAD
ACX

IDIVIDE BY 121 NON-FATAL
IGIVE ERROR MSG
IRETURN A VERY LARGE POSITIVE NUM

F'D
4-25

IFLOATING DIVIDE - USES DIVIDE-AND-CORRECT METHOD
il7006
07007
07010
07011
07012
07013
07014
07015
07016
07017
07020
07021
07022
07023
07024
07025
07026
07027
07030

4777
7410
4776
4775
7041
1044
3044
1056
7141
3056
4231
1046
305.3
1057
7650
5327
1374
3231
5267

DDDIV,
F'FDIV,

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

IDIVIDE ROUTINE - (ACH,ACL)/OPH = ACL REMAINDER REM
07031
~)7032

07033
07034
07035
~n036

07037
07040
07041
~n042
~n043

~n044

~'7045
~n~46

'H047
07050
07051
,n052
07053
kH054
'31055

'~7056

0000
1045
1056
7630
5200
1374
3054
5251
1045
7004
3045
1045
1056
7430
3045
7200
1046
7004
3046
2054
5241
5631

DV24,

DV2 ,

DV1,

0
TAD
TAD
SZL
JMP
TAD
DCA
JMP
TAD
RAL
DCA
TAD
TAD
SZL
DCA
CLA
TAD
RAL
DCA
ISZ
JMP
J:VIP 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
INOW 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 ORO OF ACL

IGO BEGIN DIVIDE
ICONTINUE SHIFT OF FAe LEFT

ACH
ACL
ACL
AC2
DV2
DV24

lFORTRAN 4 RUNTIME SYSTEM - R.L

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

PAL8-V8

PAGE 83

IDIVIDE ROUTINE CONTINUED
,n057
'H060
~n061

'H062
kn063
07064
,n065
'~7066

07067
'H070
,n071

3057
1054
7420
5265
7100
1046
7010
3054
1057
7010
2231

M? 12 L,

DVLP 1 ,

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
IOONE 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
07120
07121

SHR1,

07123
07124
07125
07126

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
5773

07127
07130

3046
5304

DVL2,

eJ7122

DVL3,
DVLl,

FO,

JMP
MP 12L
CLL CIA
DCA
ACL
CML
RAL
AC2
TAD
STL CIA
TAD
ACH
SZL
JI'1P
DVOPS
DCA
ACH
JMS
DV24
TAD
ACI
SMA
JI'I')P
F'D
CLL
ACL
ISZ
SKP
lAC
RAR
DCA
ACH
TAD
ACL
RAR
DCA
ACL
ACX
ISZ
NOP
ACH
TAD
JI'1P
DVL1+1
DCA
ACH
(MDONE
JMP I

INO-LOOP BACK
IYES-LOW ORDER PROD. OF QUOT. X
INEGATE AND STORE
IPROPAGA TE CARRY
INEGATE HI ORDER PRODUCT

DCA
JI'1P

ICOME HERE IF LOW-ORDER QUO:0
ISAVE SOME TIME

ACL
DVL3

IFORTRAN 4 RUNTIME SYSTEM - R.L

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 SHIF'T RIGHT ONE
IDOUBLE PRECISION INCREMENT

IS TORE IN FAC
ISHIFT LOW ORDER RIGHT
ISTORE BACK
IBUMP EXPONENT
IIF' F'RACT WAS 71777171 WE MUST
ISTORE HIGH ORDER RESULT
IGO LEAVE DIVIDE

PAL8-V8

PAGE 84

IROUTINE TO ADJUST QUOTINET OF' FIRST DIVIDE (MAYBE) WHEN
IREMAINOER OF' THE FIRST DIVIDE IS LESS THAN QUOT*OPL
07131
07132
07133
07134
07135
07136
07137
07140
07141
07142
07143
07144
07145
07146
07147
07150
07151
07152
07153
07154
07155
07156
07157

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

ovoPS,

OVOP 1 ,
DVOP2,

CMA
lAC
DCA
ACH
CLL
TAD
OPH
TAD
ACH
SNL
JI'l')P
DVOP 1
DCA
ACH
CMA
TAD
ACI
DCA
ACI
CLA
CLL
TAD
ACH
SNA
DCA
ACL
DCA
ACH
JMS
DV24
TAD
ACL
CLL CMA lAC
DCA
ACL
SNL
CMA
J(YlP
DVLl

4-27

INEGATE AND STORE REVISED REMAINDER

IWATCH FOR OVERFLOW
IOVERFLOW-DON'T ADJUST QUOT. OF 1
INO OVERFLOW-STORE NEW REM.
ISUBTRACT 1 FROM QUaT OF
IFIRST DIVIDE
IGET HI ORO OF REMAINDER
lIS I T ZERO?
IYES-MAKE WHOLE THING ZERO
IDIVIDE EXTENDED REM. BY HI DIVISOR
INEGATE THE RESULT
/
IIF QUOT. IS NON-ZERO, SUBTRACT
lONE FROM HIGH ORDER QUOT.
IGO TO IT

07160
07172
07173
07174
07175
07176
07177

0000
7316
6665
7763
6704
6514
6460
1200

LPBUF3, ZBLOCK
LPBUF4

PAGE

IFORTRAN 4 RUNTIME SYSTEM - R.L

PAl8-V8

PAGE 85

I" NRMFAC" AND "OP NEG" MUST 8E AT 0 AND 3 ON PAGE

07200
07201
07202

3053
4271
5476

NRMFAC, DCA
Jf1S
JIYJP I

07203
07204
07205
07206
07207
07210
07211
07212
07213

121000

OPNEG,

1057
1141
3057
1024
1056
1141
312156

5603

ACI
FFNOR
FPNXT

0
TAD
OPL
CLL CI~A lAC
DCA
OPl
CML
RAL
OPH
TAD
CLL CIYJA 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

IFLOATING SUBTRACT AND ADD
07214
07215
07216
01217
07220
07221
07222
07223
07224
07225
07226
07227
07230
07231
07232
07233
07234
07235
07236
07237
07240
07241
07242
01243
07244
01245

4777
4203
7·410
4777
1056
7650
5476
1045
7650
5236
1044
7141
1055
7540
5243
7041
4246
4541
1055
3044
4537
4271
5476
4541
4246
5236

FFSUB,
FFADD,

DOADD,

FACR,

JIYJS I
(ARGET
JIYJS
OPNEG
SKP
(ARGET
JMS I
TAD
OPH
SNA
CLA
JIYJP I
FPNXT
ACH
TAD
SNA
ClA
JMP
DOADD
ACX
TAD
Cll CI'1A lAC
TAD
OPX
SMA
SZA
FACR
Jt1P
CMA
lAC
JMS
OPSR
[ACSR
Jf1S I
TAD
OPX
ACX
DCA
[OADD
Jr1S I
FFNOR
Jf1S
FPNXT
Jf1P I
JIl'JS I [ACSR
OPSR
JMS
DOADD
Jf1P

4-28

IPICK UO THE OP.
INEGATE OPERAND
IPICK UP OPERAND
lIS OPERAND = 0
IYES-DONE
INO-IS FAC=0?
IYES-DO ADD
INO-DO EXPONENT CALCULATION
IWHICH EXP. GREATER?
IOPEHANDS-SHIFT FAe
IFAC'S-SHIFT OPERAND=DIFFRNCE+l
ISHIFT FAC ONE PLACE RIGHT
15ET EXPONENT OF RESULT
100 THE ADDITION
INORMAlIZE RESULT
IRETURN
ISHIFT FAC = DIFF.+1
ISHIFT OPR. 1 PLACE
100 ADDITION

IFORTRAN 4 RUNTIME SYSTEM - R.L

PAL8-V8

PAGE 86

IOPERAND 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
07270

0000
7040
3052
1'~56
7100
7510
7020
7010
3056
1057
7010
3057
2055
7000
2052
5251

07271
07272
07273
07274
07275
07276
07277
07300
07301
07302
07303
07304
07305
07306
07307
07310
07311
07312
07313
07314
07315

0000
1045
7,.50
1046
7450
1053
7650
5313
7332
1045
7440
5307
1046
7640
7710
5314
4534
5301
3044
3053
5671

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

07316
07376
07377

0000
7400
6514
7400

LPBUF4, ZBLOCK
LPBUFE

OPSR,
LOP2,

701~

3054
5646
FF'NOR,

CMA
DCA
TAD
CLL
SPA
CML
RAR
DCA
TAD
RAR
DCA
ISZ
NOP
ISZ
JMP
RAR
DCA
JMP I

AC0
OPH

(COUNT+l) TO SHIFT COUNTER

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

OPH
OPL
OPL
OPX

ISTORE LO ORDER BACK
IINCREMENT EXPONENT

AC0
LOP2

IDONE ALL SHIFTS?
INO-LOOP
ISAVE t BIT OF' OVERFLOW
lIN AC2
IYES-REIN.

AC2
OPSR

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

MODULE
etc.

AREA

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 exi~ts, 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 library.

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 name 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 listedG

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.

Such routines can switch between the

STARTF (3 word format) and STARTE (6 word format) pseudo-ops as required, 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 prec~s~on
(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 lO*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 fJ

/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 fJ and 3fJ of the called (user-coded) program are determined
by a statement in the form ORG 10*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 i.s required
immediately before the index register and base page assignment
statements.

Thus, if the cotangent routine includes a JSR TAN and an

5-8

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 TAN and SIN:
they are meaningful only in FORTRAN source programs.)

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
JA
JA
FSTA

ATAN2
ATAN2
.+6
A
B

ANSWER

/Execute upon exit from
/lst 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
ALOGlO
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

functions, has the standard calling sequence, and contains an error
condition exit.

I
TA N
I
I
ISUBROUTINE
SECT
JA
TANER,
TANXR,
BTAN,
XRTAN,
TAN 1,
TAN2,

EXTERN
TRAP4
TEXT
SETX
SETB
F'NOP
121
121
F' 121.121
F' 0.121
F' 0.0
ORG

F'NOP
JA
121
TANRTN, JA
BASE
STARTO
I TAN,
FLDA
F'STA
F'LDA
SETX
SETB
BASE
LDX
F'STA
F'LDA7.
F'STA
STARTF'
F'LDA 7.
JEQ
F'STA
EXTERN
JSR
JA
JA
JEQ
F'STA
EXTERN
JSR
JA
JA
F'DIV
JA

TAN(X)
TAN
I TAN
lARGER
lARGER
+
+TAN
XRTAN
BPTAN

ISECTION NAME
IJUMP AROUND BASE PAGE
IEXIT TO ERROR MESSAGE HANDLER
IF'OR ERROR TRACE BACK
ISTART OF' F'ORMAL CALLING SEQUENCE
ISTART OF' BASE PAGE
IINDEX REGISTERS
ILOCATIONS 21-42 OCTAL AVAILABLE
IF'OR USER STORAGE

10+3+BPTAN

ISET UP FOR A RETURN
ITO THIS ROUTINE

TANXR

IJUMP TO XR + RP ASSIGNMENT

0
10*3
TANRTN
0
XRTAN
BPTAN
BPTAN

ISAVE RETURN JUMP
IGET NEXT LOCATION
lIN CALLING PROGRAM
ISET UP FOR TAN'S INDEX REGS
ISET UP FOR TAN'S BP

1, 1

BPTAN
BP TAN, 1
BPTAN
BPTAN
TANRTN
TANI
COS
COS
.+4
TANI
TANER
TAN2
SIN
SIN
.+4
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
ICOS:0. A NO-NO
ISAVE IT
INOW TAKE SJN(X)
IJUMP 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

SETINT
ONQI
INTQ+l
INTQ+l
XSKP
INTQ+l
INTQ+l
ONQI
INTQ+l
ONQI
ONQI
INTADR+l
INTADR+l

JIVIP

ISZ
ISZ
DCA7.
TAD
ISZ
DCA7.
ISZ
ISZ
ONQISW, TAD7.
ISZ
DCA7.
TAD
AND
TAD
DCA7.

L177

IROUTINE TO ADD A

15ET UP INT INITIALLY
18UMP ARGUMENT POINTER
18UMP INTERRUPT Q POINTER
ISTICK lOT ONTO INT Q
IFOLLOWED BY A SKIP
10NTO I NT Q
ISKIP FIRST WORD OF ADDR

IGET INT HANDLER ADDRESS
10NTO ADDRESS STACK
IN 0 W MA KE J MS 7.

L4600

INTQ+l
INTADR+l
IQSIZE
ONQI

10NTO INT Q

lSZ

ADDR

I HANDL

IMUST USE 15 8IT ADDRESS

INTADR, ADDR

IHADRS

IROOM FOR MORE?
ISZ
JMP7.
IYES
• -1
TAD
INO, CLOSE OUT THE SUSR
ONQI+l
DCA
JMP7.
ONQI
ONQISW
SETINT, TAD
100 THIS PART ONLY ONCE
DCA
ONQI+l
CDI'
TAD
If IX UP HINT
XSKP
DCA 7.
XINT+l
IPUT SKIP INST. FIRST
XINT+l
ISZ
INTQ+l
TAD
/GET ADOR. OF USER'S ROUTINE
DCA7.
XINT+l
XINT+l
IADD TO INTERRUPT CALL
ISZ
CIFCDF'
TAD
IGET FIELD INSTRUCTION
IfIELDl SECTION INSURES ITS IN FIELD 1
DCA7.
XINT+l
CIFCDF, cor CIF' 10
JMP
ONQI+l
IBACK TO ONQI
EXTERN HINT
XI NT,
IPOINTS TO INT RTN IN COMMON
ADDR
HINT
I NTQ,

IQSIZE, -5
SKP
XSKP,
L177,

177

L4600,

4600
CDF'

IHANDL,

J;v]P7.

CIF

1 HA NDL

REPEAT 16
JMP
IHANDL-2

IHADRS, 0;0;0;0;0

ICAN SET UP 1-5 DEVICES
5-12

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

BAKR ND

BAKADR, ADDR

BHADRS

BAKQ,

BQSIZE, -S
CDF' CIF
JIt1P7.
BAKRND
BAKRND, 0
REPEAT 6
JMP
BAKRND-2
BHADRS, 0;0;0;0;0

11-5 JOBS

5-13

APPENDIX A
RALF Assembler Permanent Symbol Table

Mnemonic

Code

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

1000
5000
3000
0000
4000
7000
6000
2000

SETB
SETX
STARTD
STARTE
STARTF
TRAP 3
TRAP4
TRAP 5
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

FIELD1
IFNDEF
IFNEG
IFNZRO
IFPOS
IFREF
IFZERO
INDEX
LISTOFF
LISTON
OCTAL
ORG
REPEAT
SECT
SECT8
TEXT
ZBLOCK
IFF LAP
IFRALF
IFSW
IFNSW

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

0003
0040
0004
0001
1030
0007
1070
1000
1010
1060
1020
1050
1040
1120
1130
2000

A-I

1110
1100
0006
0050
0005
3000
4000
5000
6000
7000
0030

APPENDIX B
ASSEMBLY INSTRUCTIONS
The following sequence of commands 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 U$"
character •
. ASSIGN DTAI DEV
.R PALS
*F4.BN,LIST.LS<F4$
.R ABSLDR
*F4$
.SAVE DEV F4=O;12200$
.R PALS
*PASS2.BN,LIST.LS<PASS2$
.R ABSLDR
*PASS2$
.SAVE DEV PASS2=O;5000$
.R PALS
*PASS20.BN,LIST.LS<TTY:,DSK:PASS2$OVERLY=1
.R ABSLDR
.PASS20$
.SAVE DEV PASS20=O;7605$
.R PALS
*PASS3.BN,LIST.LS<PASS3$
.R ABSLDR
*PASS3$
.SAVE DEV PASS3=O;400$
.R PALS
*RALF.BN,LIST.LS<RALF$
.R ABSLDR
*RALF$
.SAVE DEV RALF=O;200$
.R PALS
*LOAD.BN,LIST.LS<LOAD$
.R ABSLDR
*LOAD$
.SAVE DEV LOAD=O;200
.R PALS
*FRTS.BN,LIST.LS<RTS,RTL$
.R ABSLDR
*FRTS$
.SAVE DEV FRTS=O;200
.R PALS
*LIBRA.BN,LIST.LS<LIBRA$
.R ABSLDR
*LIBRA$
.SAVE DEV LIBRA=O;200

B-1

INDEX
Argument passing, 2-10
Arithmetic expression
analyser, 1-2
Background jobs, 4-1
B~nary buffer table, 3-8
B~nary section table, 3-10
Block count sequence number,

Loader symbol table,

4-14

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
FIELDI sections, 2-13
Files, 4-13
Formatted I/O, 4-13
FRTS
Calling sequence, 4-4
Core maps, 4-6
Entry points, 4-5
Initialization, 4-14
Page zero, 4-10
Header block,

3-13

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

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
Communication, 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

/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
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
Termination, program, 4-22
Text, 2-1
TRAP3 and TRAP4, 2-8

1-2

LIBRA, 5-2
Library, 2-1
Format, 5-1
Line printer handler, 4-14
Literals, 1-4, 1-5
Loader, 3-1
Core maps, 3-2 to 3-4
Image file, 3-12
Subroutines, 3-3

3-1, 3-7

Variable type word,
8-mode sections,

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 Here ------------------------------------------------------,------

.-----------,------------------------------------ Do Not Tear - Fold Here and Staple ------------------.. ----------------------------

FIRSTCLAS~

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

_____
_____11------