⟦8d2d99318⟧

TextFile

corecodeman=set 63 disc3
global corecodeman
corecodeman=compose
*pl 297,18,250,4,3**pn 0,0*
*lw 175**ps 0**sj*
H. C. Ørsted Institute
Computer Department
Universitetsparken 5
DK-2100 København Ø
*nl4*
*ct*
HCØ RC8000 algol8 library
core code system
"corecodeman"
*nl8*
Anders Lindgård
*sj* *nl19**lm 120*
80-5 *lm120**nl*
1980-11-20
*nl*
*rj**pn 5,0**ps 18*
*lm0*
Copyright 1980 Anders Lindgård.*nl*
For the time being
this procedure set can be used freely for
research or other nonprofit purposes. Any
other use demands written permission from
the author.
*ns 1,4,Core code system*
        ------------------------*nl**np*
In some applications it is essential to optimize the speed  of the
code and at the same time keep the number of segment transfers
as low as possible. External slang coded procedures are
not practical if the code fills mode than two segments as the
programmer cannot prevent segment transfers. It is however
very convenient to write most of a program in a high level
language. This system is designed to give a programmer a
possibility for using rather large slang coded parts
in an algol program.
*nl 1,2,The system on algol level**nl*
*np*
On algol level the system consist of three parts:*nl*
*np25*
A user declared array holding the binary code to be
executed and addresses of variables, expressions etc.
*np25*
An algol procedure "initcode" which initializes the 
array with the code taken from a backing store area and
with addresses.
*np25*
An algol procedure "callcode" which makes jumps to the
code at specified relative addresses.
*nl**np*
In this way an algol program is no longer self contained,
but it is possible to retranslate the slang code part
without retranslating the algol program.
*ps0*
*qr*
1980-11-20
Anders Lindgård
*nl2*
*ct*
integer procedure initcode
*nl2*
*rj**np*
Loads an array with the preassembled slang code from the backing store.
The addresses for all parameters and some information about the core code
and the surroundings is stored in the array.
*nl2*
Call: initcode(A,name,sourcelist)*nl*
*lm55*
*mt 1,      initcode**cm 6 spaces*(return value, integer).
*nl*
The number of bytes in the array used for addresses, constants and code.
*nl*
*mt 1,      A*(call  and return value, <any type> array).
*nl*
The array whic hold the code and constants, adresses etc. See below.
*nl*
*mt 1,      name*(call value, string).*nl*
The name of file holding the preassembled code.
*nl*
*mt 1,      sourcelist*(call value, list of <any type> of
           parameters).
*nl*
The source parameters.
*lm0**nl4*
If a source parameter is an expression the value is computed and
stored in A. An integer expression uses 2 halfwords. A relal or 
long expression uses 4 halfwords. The procedure has no way of
determining whether the user needs a result of another type than
the type of the expression, so all type conversions must be done
explicitly by the user.
*np*
A constant uses 2 or 4 halfwords according to its type
*np*
In the algol system addresses of arrays are odd and points to the first halfword in
the array. 
The procedure delivers all addresses as even i.e. the last bit of an
address is allways set to zero.
*ns 1,2,Error messages*
        --------------
*se?*
?sj?
***<name> <result>
   The file described by <name> could not be connected.
   The result of create area process is shown.
***claim 0
   The buffer claim was zero at entry to the code.
?se*?
*rj*
*ns 1,2,Language: SLANG*
        ---------
*ns 1,2,Maintenance level: user*
        ------------------
*ps0*
*qr*
1980-11-20
Anders Lindgård
*nl2*
*ct*
integer procedure callcode
*nl2*
*rj**np*
The procedure makes a jump to the code stored in the array A.
*nl2*
Call: callcode(A,relative)*nl*
*lm55*
*mt 1,      callcode**cm 6 spaces*(return value, integer).
The content of working register w1 at exit from the code.
*nl*
*mt 1,      A*(call and return value, <any type> array).
*nl*
The array which holds the core code. See initcode.
*nl*
*mt 1,      relative*(call value, integer).
*nl*
The relative address for the first instruction to be executed.
See below.
*lm0**nl4*
The entry address in the array A is calculated in the following way:
*nl2*
entry address:=base+entry point code+relative
*nl*
where
*nl*
base:=appetite+10
*nl*
entry point code is the last byte of word 9 in the tail of the
catalog entry for the file holding the code
*nl*
appetite:=the number halfwords used for addresses and constants
*ns 1,2,Language: SLANG*
        ---------
*ns 1,2,Maintenance level: user*
        ------------------
*ps0*
*ns 1,2,The system on slang level*
        -------------------------
*np*
After a call of initcode the array A contains the
following:
*sj*
first address in A

+ 0 undefined                                   return address)
+ 2 address of first instruction                base+entry    )
+ 4 halfword occupied by addresses,
    constants and expressions                   appetite      ) head
+ 6 address of running system                   RS base       )
+ 8 address of file processor                   fp base       )
+10 address of 1. parameter (even)
+12 address of 2. parameter (even)
.
.
+10+appetite           last constant or last result of an expression
+12+appetite=base 
    + 0                address of first assembeld instruction
    +entry             address of entry point
    +entry+relative    (relative undefined at call of initcode)
                       first instruction executed by callcode
*rj**nl2**np*
When callcode is entered the following is done:
*nl*
The return address is stored in the first word of A.
The working registers are initialized.
*sj*

w0   0
w1   address of first word in A.
w2   appetite
w3   return address
*rj*
At exit w1 is delivered as result of callcode.
*ef*
▶EOF◀
DataMuseum.dk

RC4000/8000/9000

⟦8d2d99318⟧ TextFile

Derivation

TextFile
