⟦b35e4684c⟧

TextFile

;ali time 5 0
(networkref=set 100
permanent networkref.17
networkref=typeset
if ok.yes
c=copy message.no networkref
)
*pl 297,18,240,4,3**pn 0,0*
*lw 170**ps 0**sj*
H. C. Ørsted Institute
Computer Department
Universitetsparken 5
DK-2100 København Ø
*nl4*
*ct*
Reference manual

for

the RC4000 microcomputer network
"networkref"
*nl6*
Anders Lindgård
*sj* *nl19**lm 120*
79/1 *lm120**nl*
June 1979
version 1979-11-12
*nl*
*rj**pn 5,0**ps 18*
*lm0*
*ns 1,2,Foreword*
--------*nl**np*
This manual is intended as a referencemanual both for the user of the
system and for the systemsprogrammer. It thus contain many details which
the user do not need to know for practical use of the system.
*np*
This manual describes only the RC4000 part of the system. The micro-
computer part is described by Eivind Sørensen elsewhere.
*nl**np*
The RC4000 part of the system was designed and implemented by the
author. The microcomputer part by Eivind Sørensen.
*nl**np*
This manual is stored as a textfile on the RC4000 backing store
under the name "networkref".
*ps18*
*rj*
*nl6*
*ld24*

*ns 1,2,Introduction*
------------*nl**np*
The HCØ M6800 microcomputer network is a hierarchical star network
controlled by the RC4000 computer.*nl2*
It supports datacollection and control of experimental setups, where a
local microcomputer perform the datacollection and control, while
the RC4000 provides, back-up facilities and datahandling.*nl2*
The network supports local peripherals known to computational activities
inside RC4000 except for typewriter terminals.
*ns 1,2,System design*
-------------*nl**np*
A network design was selected to be able to support
clusters of experiments at long distances where cabling costs
else might be prohibitive.*nl2*
Primary design criteria for as well hardware and software are
to develop the system as a number of simple modules
with welldefined and simple interfaces and to isolate
the modules from each to other to minimize the effects
of component breakdown. Each experiment is connected
to its own small microcomputer.
This computer is further connected through the network to
the central system using cheap serial lines just like
terminals. In the central system a microcomputer is
frontend to the main multiprogrammed computer acting
as a multiplexer for a number of local microcomputers,
*nl2*
Control in the system is hierarchical with the RC4000 as
the ultimate master. It is implemented having a monitor
program in a read-only-store in each local microcomputer.
Through this monitor the multiprogrammed computer may
load programs into the local microcomputer directly
eliminating the need for a local load device. On the
other hand the local microcomputer may be disconnected
from the central system and connected again without any
harm on the local user program and collected data.*nl2*
The idea of having a monitor in the local microcomputer
gives us the posibility to provide users with a much
more atractive machine than the naked hardware. There
are standard driver programs for the types of
peripherals supported and a communication package for
exchanging blocks of data with the RC4000. This
implies that the individual user programs usually are
very short and thus relatively easy to develop.
Another advantage is that it is possible for the
central computer to read parts of the store when a
user program is running.*nl2*
In the central system the multiplexer microcomputer is
much like a local microcomputer. The same monitor
as for the local microcomputers
is used. The multiplexer program is a user program
just like a datacollection program in a local microcomputer.
The software and its interfaces thoughout the system
are very uniform and closely related to the RC4000
multiprogramming monitor (Brinch Hansen , 1973). This
uniformity made it easy for us to develop the system
software and will make it easy to maintain it. The
software is designed to give the users a strong support
and is at the same time flexible.*nl2*
High datatransmission speed between the local microcomputer
and the central system is not considered important
and this is the main argument for selecting cheap
serial lines with a transmission speed of 50k baud.
Users who needs high datacollection rates usually
only need this for a very limited time so the local
microcomputer store can provide buffering until the
central system has received the data. The datatrans-
mission is implemented with a number of (logical)
channels between the RC4000 and the local microcomputer.
*nl2*
*ns 1,2,Structure of the network*
------------------------*nl**np*
The network is strictly hierarchial in control, i.e. a master may
perform actions like start, stop, load the store at an absolute
address in a slave. Only a master may send
messages to a slave. A slave can thus only give answers to messages.
Theese restrictions are basically due to the implementation of
processes and their way of communication in the RC4000. *nl2*
To simplify the system there are only 5 levels in the hierarchy.
*ns 1,2,Structure of a microcomputer in the Network*
--------------------------------------------*nl**np*
A microcomputer is build around the Motorola M6800 central
processor. The store is divided into a user part and a monitor part.
The user part is of minimum 16 k bytes and maximum 57 k bytes.
The monitor part is 4 k bytes EPROM for a monitor program and 1 k
bytes for variables to the monitor. The monitor program may be
called from the user program to perform input/output on the user
peripherals. The monitor program receives messages from the master
and performs control functions towards the user program.
Other messages from the master
are forwarded to the user program which may
wait for such messages, and is expected to perform the necessary actions.
*nl2*
The monitor program implements a number of processes. Each process
is identified by a name. Processes may send messages to each
other using message buffers. Processes may be divided into
system processes and peripheral processes for user devices. *nl*
*sj*
The system processes are:

1. the master
2. the clock
3. the user process (only one)
*rj**nl*
and they exist to any time. Peripheral processes for user
devices are created by calling a monitor procedure 'create peripheral'.
*ns 1,2,Process and computer communication*
----------------------------------*nl**np*
The philosophy behinds this monitor follows that of the RC4000 monitor.
Procedures like 'send message', 'wait answer', 'wait message',
'send answer' and 'wait event' are essentially copied from
the RC4000 monitor.*nl2*
In hardware the communication between two microcomputers goes
through three serial channels. A command channel, for information
from the master to the slave. A request channel for the other way.
A data channel for block transfers between the two computers
initiated by information send through the command channels and
the request channel.*nl2*
In software there are 8 channels between a master and a slave.
Each channel is controlled using messages and answers in a single
messagebuffer. 7 of the channels may be used for any purpose
and simoultaneusly. The 8th channel is for restarting a slave
from scratch called an autoload message.
A channel is identified by a channel index.*nl2*
The user process wil be either a multiplexer program for up to
15 slave microcomputers, a device control program for up to
15 peripherals known internally in the RC4000 or a datacollection
and control program.*nl2*
It is intended that a single microcomputer will only run one
single type of task, for example being a multiplexer computer,
or datacollection computer.
*ns 1,2,The RC4000 monitor program*
--------------------------*nl**np*
In the RC400 monitor the network is simulated as a number of
processes shown in figure x. Closest to the interface hardware
is the 'main micro' process which has three subprocesses
'dma', 'trm' and 'rec' which control the DMA-transfer,
the transmitter registers and the receiver registers respectively.
Below the 'main-micro' there is a process for each local
microcomputer and each local peripheral to be known in the RC4000 system.
The process structure reflects the connection of computers in the
system and is at present a fixed structure which can only be
altered by changing the RC4000 monitor.
* ns 1,2,Handling of a message.**np*
When a message is received by a "local" process a channel
index is selected if possible, else the buffer is
queued until a channel index becomes available.*nl2*
An autoload message has allways channelindex= max
channelindex and is allways served.
The autoload message rejects all messages in the system

originating from this process or any process lower in
the hierarchy.
The "local" process now set up a
primitive message in the message buffer
(buf + 16 and buf + 18) where the first word
contain the message and the second the receiver of
this primitive message concatenated with the
channelindex. The message buffer is then send to
the "main" process.*nl2*
The "main" process performs a numbers of conversations
with the "trm" process and the "rec" process for each
message received from "local".*nl2*
Messages are not necessarily handled to completion
in the same order as send to the "local". As
the system works it may be regarded as the main
process has 4 queues. One for autoload, one for
other even messages, one for input and one for
output. The "user" process in the "local" may how-
ever answer messages send to it in any order.*nl2*
For an even message "main" sends the messagebuffer to
"trm". When an answer is received
from "trm" the messagebuffer is send to "rec"
to wait for a primitive answer. "rec" returns the
messagebuffer to "main" which then returns it to
"local" where the final answer is set up and the
channel index released. The messagebuffer is returned
to the sender.*nl2*
For input "main" first exequtes the same sequence of
operations as for an even message. When the answer
comes from "rec" the messagebuffer is send to the "dma"
process which performs block input-output. When the "dma"
has answered to "main" a "release block" primitive
message is send through "trm" and "rec" and the answer
goes to "local".*nl2*
For output "main" first sends a "find block
index" primitive message through "trm" and "rec"
Then "dma" perform the operation and finally an
output primitive message is send through. All
theese operations uses the same message buffer.*nl2*
If the sender is stopped during the handling
of an input or output message the messagebuffer is
returned to the sender with halfwords=bytes=0.
This may often be the case when the operating system
uses swopping for storemultiplexing between
several processes. For
input the block is held in the physical main
M6800 computer ready for a new input message,
as "main" issues a "wait block" message instead of
the "release block" message.
In order to prevent data blocks from tying up store indefinetely
in the main M6800 the data blocks are released for other use
after 30 sec.
*nl*
*ns 1,2,Format of a messagebuffer when used by the subprocesses.*
---------------------------------------------------------*nl**np*
*sj*
Contain a message

buffer address

+ 8 <operation><12+<mode>
+10 <first address>
+12 <last address>
+14 <coroutine number><+16<first address local>
+16 <primitive message 1. word>
+18 <identification word>
+20 <save message or answer>
+22 <save original receiver>

Contain an answer before it is returned to the sender.

+ 8 <status><12+<result>
+10 <bytes>
+12
+14 <coroutine index><16
+16 <primitive answer 1. word>
+18 <identification word>
+20 <save message or answer>
+22 <save original receiver>
*rj*
*nl2*
When a message buffer is processed by the system it is used
to store all information used by the various subprocesses
when handling the message in the system.
*nl2*
The coroutine index is used by the "main" process for
selecting the next piece of code to be executed when
the message is returned from "dma", "trm" or "rec".
The primitive message to be executed by "trm" is stored
in buffer index +16 and +18. When a message is
broken up into several messages as is the case for
blocktransfer messages the original message may be stored
in buffer index +20 while some other message is handled.
Save original receiver contain the process description
address of "local" when the message is handled by the
system processes. Buffer address +4 will contain the
process description address of the "main" system process.
*nl2*
When an answer has been generated buffer address +8
will contain status bit for operation performed in the
RC4000. Result is the result to be delivered by
"wait answer".
*ps**lm20**ld24*
Network local microcomputer
*lm 0*
*ns 1,2,General rules**np*
Operations can only be initiated by an internal process that has
reserved the device. Some local microcomputers further require
that the user has function bit 8 in the function mask. The number
of messages which the system handles concurrently is limited.
Normally the user may expect to be able to have 7 channels open
simoultaneonsly. A eight is reserved for an autoload message.
The number of blocktransfers which may be handled
simoultaneonsly by the system is further limited.
*ns 1,2,Sense operation**np*
The state of the 'user process' concatenated with the state of
the monitor is delivered as an answer.
*ns 1,2,Input operation.**np*
A segment of 256 words is input to a storage area within the
sending process. If the sender is stopped before the operation
has taken place halfwords and characters are zero else they
are 512 and 768.
*sj*

Transfer completed
*rj*
*nl2**np*
A message is forwarded to the
user program in the M6800. The even part of the 2. word of the message may be
read by the userprogram. Intended for syncronizing the RC4000 user program
and the M6800 user program.
*sj*

Output operation
Equivalent to input operation.
*rj*
*nl2*
Start user operation*nl*
The user process is started if it was in the state 'waiting for
start' else it is a dummy operation.*nl2*
Stop user operation*nl*
The user process is stopped i.e. set in the state 'waiting for
start'. If that was already the case it is a dummy operation.*nl2*
Autoload operation*nl*
Initializes the microcomputer. The microcomputer is included in
the network and is ready to be loaded with a program. All pending
transfers to that microcomputer are rejected and so are pending
transfers to microcomputers lower in the hierarchy.
All processes lower in the hierarchy are locked (see lock processes).
*nl2*
Lock processes operation.*nl*
All processes lower in the hierarchy are
reserved by the calling proces, without regard to other
reservations. All pending transfers to that microcomputer
are rejected and so are all transfers to microcomputers lower
in the hierarchy.*nl2*
Unlock processes operation*nl*
For all processes lower in the hierarchy reservations are cancelled.
*nl2*
*sj*
Messages and answers:
*ld8*

Operation: message answer
sense 0<12+mode status word
not used
program status word
input 3<12+mode status
first address bytes
last address program status word
first address local

transfer completed 4<12+mode status
block number<1 not used
program status word

output 5<12+mode status
first address bytes
last address program status word
first address local

start user 2<12+mode status
not used
program status word

stop user 6<12+mode status
not used
program status word

autoload 8<12+mode status
not used
program status word

lock processes 10<12+mode 0

unlock processes 12<12+mode 0
*nl2*
*ld16*
*rj*
mode*nl*
Legal mode values are 0,1,2,3,4,5,6,7. For odd operations
mode 0 specifies input or output at the absolute
address given by first address local. If mode >0 the
input or output message is handed
over to the user program.*nl2*

status bits
*sj*
1<22 data overrun
1<21 timeout
*rj*
*nl*
Status bit 0 - 6 are taken from the primitive answer
see below*nl2*
program status word is taken from the promitive
answer, see below
*nl6*
*lm20*
*ps*
Formats for communication between computers.*nl*
(primitive messages and answers)
*lm 0*
*sj*

A primitive message or primitive answer consist of two 24 bit words.

Message
*rj*
*nl2*
The first word of a message or an answer is identified by a
zero in the least significant bit. The second word by a one.
A message has a zero in the most significant bit of the first
word. An answer has a one. The second word of a message or an
answer identifies the receiver (bit 0 through 19) and the communication
by a channelindex 'ch'
(bit 19 through 22).
Thus the format allows up to 8 messages
to be handled simoultaneously. The 'receiver' part of the second
word is split into five 'levels' of 4 bit each, allowing a dept
in the computer hierarchy of five, where the 'netmain' is
level 0. (see below) *nl2*
*ns 1,2,Message:**np*
'opcode' (bit 1 through 7 is interpreted as an operation and a mode,
with the 4 most significant bits as operation and the 3 least
significant bit as mode.*nl*
*sj*

opcodes
0<3 sense device
2<3 start user
4<3 transfer completed
6<3 stop user
8<3 autoload local
10<3 find free block number
12<3 release blocknumber
14<3 wait block
3<3 input block
5<3 output block

Mode is not used by the system but is forwarded to the receiver
of the primitive message
*rj*
*nl2*
The address part of a message (bit 8 through 22) is used by the
odd operations to give an address in the local microcomputer
from where input or output should start.*nl2*
The release block number operation
uses only bit 16 through 18, which gives the index of a block to be
released.
The wait block operation is used in connection with input
to signal that this block has to wait for a new
input operation to take place.
In transfer completed this field is a free parameter.
In all other even operations the address part is undefined.
*ns 1,2,Answer**np*
'Status' (bit 1 through 7) gives status for the operation
performed. All bits zero indicates succesfull operation.
In the RC4000 theese bit will be part of status
in the answer.*nl*
*sj*
status

bit meaning
1<0 rejected, timeout on communication channel
1<1 rejected, receiver does not exist
1<2 rejected, after autoload
1<3 rejected, illegal address
1<4 rejected, master clear
1<5 rejected, illegal operation
1<6 rejected, device disconnected
*rj*
*nl2*
If bit 2 and 6 are both set the identification of a local micro-
computer is inconsistent with the identification assumed by its
master.*nl*
'no' (bit 8 through 11) gives the number of the receiver
on the 'level' (bit 12 through 15). This information may also
be decoded from the second word.*nl*
'block' is the block index used in this transfer. Has only meaning
if the operation in the message is odd or an 'find
free block' "release block" or a "wait block" operation.*nl2*
*sj*
'userstatus' (bit 19 throgh 22) gives information about current
state of the user process

value meaning
0 no process or stopped
1 running
2 waiting for message
4 waiting for answer
8 waiting for event
*rj**nl2*
In the RC4000 this value is put into the program
status word of the answer.*nl2*
The primitive messages are served by the monitor program
in the local microcomputer. The monitor may be in
two states.
One "unnamed" where it does not know its own identification
word, and the othe "named" where an autoload message
has defined the identification word. In the unnamed state
only autoload messages are accepted from the master.
In the named state the monitor itself serves the message
if the whole identification word matches the identification
word of the primitive message.
If any bit in the next lower level
is set, the primitive message is handed over the user
program. As a convention the RC4000 monitor program sets
all 4 bit in the next lower level for input-output messages
when mode is different from zero in the RC4000
message, and also for "transfer completed".
*ns 1,2,Conventions for data blocks*
---------------------------*nl**np*
When data blocks are transferred between a local microcomputer
user program and the RC4000 the standard programs will use
the first part of the block as a header to describe details
of the transfer in a standard way. A block is regarded as
256 words of 24 bit and has the following format (RC4000
halfwords used for relative addresses).
*nl2*
*sj*
Block layout

+ 0 <size of header=h in bytes (8 bit)>
+ 2 <size of data block=s in bytes (8 bit)>
+ 4 <block number of this block>
+ 6 <information type>
+ 8 <record size>
+ 10 <status>
+ 12 <device number of local peripheral>
+hx3/2 <first datum>
+(hx3 + sx3 +3)/2 <last datum>
*rj*
*nl2*
<size of header> h gives the number of bytes of
the header part of this block. May vary from block to
block.*nl2*
<size of data> s gives the number of bytes of data
in this block. Must fulfill s <768 - h.*nl2*
<block number> gives the blocknumber of this block.
It is assumed that blocknumbers are unique. The
block number is encoded into <first address local>
together with some part of <information type>.
see below.
When data are stored on the RC4000 backing store
<block number> is used as segment address.*nl2*
<information type> is used as follows:*nl2*
The last four bit (bit 20 to 23) gives the size of
a datum in bytes.*nl*
The next four bit (bit 16 to 19)
give the data type of the information.*nl2*
*sj*
datatype

0 = ISO characters
1 = integers (2. complement)
2 = integers (positive)
3 = BCD integers

The next four bit (bit 12 to 15) gives the information
as follows

0 = data
1 = message block
2 = answer block
*rj**nl2*
This information is also found in the <first address local>
part of the message area (or primitive message) which is
a free parameter when the user program is the receiver
of the input-output message.*nl*
<record size> gives the number of 8 bit bytes in a record.*nl2*
*sj*
<status> is used as follows:

If all bits are zero the block is a normal block:

Bit
1<0 hard error
1<2 device could not be created
1<3 device recognizes message as unintelligible
1<4 device is disconnected
1<5 device does not exist
1<6 device gives parity error
1<7 device gives timeout
1<10 last block
*rj*
*nl2*
<device number of local peripheral> is used to identify
where device data comes from or goes to. May be omitted.
*ns 1,2,Primitive message convention.*
------------------------------*nl**np*

As the <first address local> is a free parameter when the
local user process is destination for input-output
messages <mode> 0 in the RC4000 message it can be used to
give a easy identification of a block. If this word is
greater than zero it is the block number. If less than
zero it is a message block or an answer block. An answer
block further has the sign bit of the last byte
(bit 16) equal to one. Message blocks and answers blocks
should be numbered sequentially to ensure that they will
be processed sequentially by the system.
*ns 1,2,ALGOL procedures and variables.**np*
On the algol level the microcomputers may be handled
by the primitive procedures described below.*nl2*
*sj*
Procedures:

netoperat (name,operation);
netabsio (name,operation,first address,data);
netprogload (name,program);
*rj*
*nl2*
Multibuffered block transfers between an RC4000 user program and
the local microcomputer user program are most
effectively handled using "send message" "wait answer"
directly. For an example of use see appendix I.*nl2*
Besides the procedures some standard variables
exist and are used or set by the procedures.*nl2*
*sj*
Variables:

op_sense
op_start
op_stop
op_transfer
op_autoload
op_input
op_output
net_error
net_io_s_w
net_prog_s_w
*rj*
*nl2*
The first 5 may be used in the call of "netoperat"
as operation code. The 2 next in "netabsio".
"neterror" is a boolean initialized to true and will
cause the procedures to write error messages on
current output.*nl2*
The last 2 variables contain the statusword for
the last operation issued, "netiosw", and the
local user program status word, "netprogsw".
Theese two variables are set by the 3 procedures
after each operation.*nl*
*lw 180* *ld 12* *ps0*
*qr*
1979-03-01
Anders Lindgård
*nl2*
*ct*
integer procedure net_operat
*nl1*
*rj**np*
Executes either a sense,start,stop,autoload or transfer completed operation on a microcomputer
in the RC4000 microcomputer network.
*nl2*
Call: net_operat(name,operation,block)*nl*
*lm55*
*mt 1, net_operat**cm 6 spaces*(return value, integer).
The result of the operation. If operation was executed then 1.
*nl* 0 operation illegal.
*nl* <6 operation rejected. Result of wait answer.
*nl* >8 reservation error. Result of reserve process +8.
*nl*
*mt 1, name*(call value, string). The name of
the microcomputer.
*nl*
*mt 1, operation*(call value, integer). Operation code
Must be either a sense, start, stop, autoload or transfer completed operation.
The standard variables op_sense, op_start, op_stop, op_autoload, op_transfer may be used.
*nl*
*mt 1, block*(call value, integer). Only used by transfer
completed, where it is communicated to the M6800 user process
as a blocknumber (even).
*lm 0*
*nl1*
*np*
The procedure assign values from the answer area to to the standard variables
net_io_s_w and net_prog_s_w.
*ns 1,2*Warnings*
--------*np*
In case of an error a warning is written on
current output, but the program is not terminated.
If neterror has been set to false no warning is written.
*se/*
/nl/**netoperat <name> operation error
/nl/**netoperat <name> not reserved <result>
/nl/**netoperat <name> result <result> wait answer
/nl/**netoperat <name> status <bitpattern>
/se*/
*ns 1,2,Language*
--------*nl*
ALGOL
*ns 1,2,Maintenance level*
-----------------*nl*
user
*ps0*
*qr*
1979-03-01
Anders Lindgård
*nl2*
*ct*
integer procedure net_abs_io
*nl1*
*rj**np*
Performs an input operation from or an output operation to a microcomputer
in the RC4000 microcomputer network.
One segment is transferred to or from an absolute address in
the local microcomputer.
*nl2*
Call: net_abs_io(name,operation,data_block,first_address)*nl*
*lm55*
*mt 1, net_abs_io**cm 6 spaces*(return value, integer).
The result of the operation. If operation was executed then 1.
*nl* 0 operation illegal.
*nl* <6 operation rejected. Result of wait answer.
*nl* >8 reservation error. Result of reserve process +8.
*nl*
*mt 1, name*(call value, string). The name of
the microcomputer.
*nl*
*mt 1, operation*(call value, integer). Operation code
Must be either an input or output operation.
The standard variables op_input, op_output may be used.
*nl*
*nl*
*mt 1, data_block*(call or return value, integer array). The data
are transferred to or from this array. Must have at least 256 elements.
This is however not checked.
*nl*
*mt 1, first_address*(call value, integer). First byte address
in local microcomputer.
*lm 0*
*nl1**np*
The procedure assign values from the answer area to to the standard variables
net_io_s_w and net_prog_s_w.
*ns 1,2*Warnings*
--------*np*
In case of an error a warning is written on
current output, but the program is not terminated.
If neterror has been set to false no warning is written.
*se/*
/nl/**netabsio <name> operation error
/nl/**netabsio <name> not reserved <result>
/nl/**netabsio <name> result <result> wait answer
/nl/**netabsio <name> status <bitpattern>
/se*/
*ns 1,2,Language*
--------*nl*
ALGOL
*ns 1,2,Maintenance level*
-----------------*nl*
user
*ps0*
*qr*
1979-03-01
Anders Lindgård
*nl2*
*ct*
integer procedure net_prog_load
*nl1*
*rj**np*
Loads a program found on the RC4000 backing store into a microcomputer
in the RC4000 microcomputer network.
The program is loaded to address 0 and forward in the local microcomputer.
The program is fetched from segment one of the backing store area and is
assumed that tail(10) contains the number of halfwords to be transferred.
This convention is used by the general table driven assembler genas.
*nl2*
Call: net_prog_load(name,program)*nl*
*lm55*
*mt 1, net_prog_load**cm 6 spaces*(return value, integer).
The result of the operation. If operation was executed then 1.
*nl* 0 operation illegal.
*nl* <6 operation rejected. Result of wait answer.
*nl* >8 reservation error. Result of reserve process +8.
*nl*
*mt 1, name*(call value, string). The name of
the microcomputer.
*nl*
*mt 1, program*(call value, string).
The name of the backing store file which holds the program.
*lm 0*
*nl1**np*
The procedure assign values from the answer area to to the standard variables
net_io_s_w and net_prog_s_w.
*ns 1,2*Warnings*
--------*np*
In case of an error a warning is written on
current output, but the program is not terminated.
If neterror has been set to false no warning is written.
*se/*
/nl2/**netprogload <name> not reserved <result>
/nl/**netprogload <name> result <result> wait answer autoload
/nl/**netprogload <name> status autoload <bitpattern>
/nl/**netprogload <program> lookup result <result>
/nl/**netprogload <program> areasize <segments> load size <halfwords>
/nl/
Further warnings may come from the procedure net_abs_io
/se*/
*ns 1,2,Language*
--------*nl*
ALGOL
*ns 1,2,Maintenance level*
-----------------*nl*
user
*ef*
▶EOF◀

DataMuseum.dk

RC4000/8000/9000

⟦b35e4684c⟧ TextFile

Derivation

TextFile