DataMuseum.dk

Presents historical artifacts from the history of:

RC4000/8000/9000

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about RC4000/8000/9000

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - metrics - download

⟦3655088f7⟧ TextFile

    Length: 12288 (0x3000)
    Types: TextFile
    Names: »texecintf1«

Derivation

└─⟦621cfb9a2⟧ Bits:30002817 RC8000 Dump tape fra HCØ.  Detaljer om "HC8000" projekt.
    └─⟦0364f57e3⟧ 
        └─⟦ef5fa0e68⟧ »jtas« 
└─⟦667bb35d6⟧ Bits:30007480 RC8000 Dump tape fra HCØ.
    └─⟦4334b4c0b⟧ 
        └─⟦ef5fa0e68⟧ »jtas« 
            └─⟦this⟧ 

TextFile

; code procedures for normal algol-tasks interfacing to   e x e c
; and the call of the algoltask

b. g1, e30 w.       ; block for tails and insertproc
d. , p.<:fpnames:> , l.
k=10000

s. b10, f10, j50, g5; start slang segment
h.
g0=0                ; no of externals
e5:
g1:  g2   , g2      ; head word
j3:  g0+3 , 0       ; rs entry  3 : reserve space
j4:  g0+4 , 0       ;  -  -     4 : take expr
j5:  g0+5 , 0       ;  -  -     5 : goto point
j6:  g0+6 , 0       ;  -  -     6 : end integer expr
j8:  g0+8 , 0       ;  -  -     8 : end addr expr
j13: g0+13, 0       ;  -  -    13 : last used
j30: g0+30, 0       ;  -  -    30 : saved w3, stack ref

g2=k-2-g1

w.
e0:  g0             ; start external list
     0              ; 0 hw in own core
     s3    , s4     ; date, clock

; variables
f2:  0              ; work
f9=20               ; real addr of entryaddr to exec-proc
f10: 0 , r.15       ; paramarea for exec calls
\f


; exec interface                                       page 2
; procedures with no params
e10: am        -1     ; end task(1)
e11: am        -1     ; abort(2)
e12: am        -2     ; check void(3)
e13: am        -1     ; logout(5)
e14: al  w1     6     ; stop appl(6)
     rl. w2    (j13.) ; saved w3, stack ref
     ds. w3    (j30.)
     jl. w3     b9.   ; call exec-proc
     jl.       (j8.)  ; end addr expr (only check void)

; procedures with one integer call param
e15: rl. w2    (j13.) ; split(9), reschedule
     ds. w3    (j30.) ; saved w3, stack ref
     jl. w1     b1.   ; take 1. param
     rl  w0  x1       ; w0:=time
     al  w1     9
     jl. w3     b9.   ; call exec-proc

; integer procedures with one integer call param
e16: am        -4     ; start alien(10)
e17: am        -1     ; get excb(14)
e18: am        -7     ; put excb(15)
e19: al  w1     22    ; write ctbl(22)
     rs. w1     f2.   ; save procno
     rl. w2    (j13.)
     ds. w3    (j30.) ; saved w3, stack ref
     jl. w1     b1.   ; take 1. param
     rl  w0  x1
     rl. w1     f2.
     jl. w3     b9.   ; call exec-proc
     rl  w1     0     ; w1:=status
     jl.       (j6.)  ; end intg expr
\f


; exec interface                                       page 3
; integer procedures with one integer call,return param
e23: am        -1     ; reserve excb(12)
e24: al  w1     13    ; release excb(13)
     rs. w1     f2.   ; save procno
     rl. w2    (j13.)
     ds. w3    (j30.) ; saved w3, stack ref
     jl. w1     b1.   ; take 1. param
     rl  w0  x1
     rl. w1     f2.
     jl. w3     b9.   ; call exec-proc
     rl  w1     0     ; w1:=status
     rl  w0     4     ; w0:=excbno
     dl. w3    (j30.)
     rs  w0 (x2+8)    ; store excbno
     jl.       (j6.)  ; end intg expr
\f


; exec interface                                       page 4
; integer procedure dump(type,start index, end index,long array)
b. m10 w.
e25: rl. w2    (j13.)
     ds. w3    (j30.) ; saved w3, stack ref
     jl. w1     b1.   ; take 1. param
     rl  w0  x1
     rs. w0     f10.  ; store dumptype in paramarea
     jl. w1     b2.   ; take 2. param
     rl  w1  x1
     al  w1  x1-1
     ls  w1     1     ; convert index to hw
     rs. w1     f10.+2; store rel startaddr
     jl. w1     b3.   ; take 3. param
     rl  w1  x1
     al  w1  x1-1
     ls  w1     1     ; convert index to hw
     rs. w1     f10.+4; store rel endaddr
     dl  w1  x2+20
     ea  w1     0     ; w1:=dope addr long array
     al  w3     8
     al  w0     0
     sh  w3 (x1-2)    ; if lowindex<>1 or high index<2 then
     se  w0 (x1)      ; status:=4
     jl.        m1.
     rl  w3 (x2+20)   ; move text in array to paramarea
     dl  w1  x3+4
     ds. w1     f10.+8
     dl  w1  x3+8
     ds. w1     f10.+12
     al. w2     f10.  ; set params for dump call
     al  w1     4
     jl. w3     b9.   ; call exec-proc
     rl  w1     0     ; w1:=status
     se  w1  x1
m1:  al  w1     4     ; status:=4
     jl.       (j6.)  ; end intg expr
e.
\f


; exec interface                                       page 5
; integer procedure write terminal(applid,emergency,broadcast,phtid)
e26: rl. w2    (j13.)
     ds. w3    (j30.) ; saved w3, stack ref
     jl. w1     b1.   ; take 1. param
     rl  w0  x1
     rs. w0     f10.  ; store applid in paramarea
     jl. w1     b2.   ; take 2. param
     rl  w0  x1
     rs. w0     f10.+2; store emergency in paramarea
     jl. w1     b3.   ; take 3. param 
     rl  w0  x1
     rs. w0     f10.+4; store broadcast in paramarea
     jl. w1     b4.   ; take 4. param
     rl  w0  x1
     rs. w0     f10.+6; store phtid in paramarea
     al. w2     f10.  ; set params for exec proc
     al  w1     11
     jl. w3     b9.   ; call exec-proc
     rl  w1     0     ; w1:=status 
     rl  w0     4     ; w0:=phtid pointer
     dl. w3    (j30.)
     rs  w0 (x2+20)   ; store phtid
     jl.       (j6.)  ; end intg expr

; integer procedure priority(min,max)
e27: rl. w2    (j13.)
     ds. w3    (j30.) ; saved w3, stack ref
     jl. w1     b2.   ; take 2. param
     jl. w1     b1.   ; take 1. param
     rl  w0  x1       ; set params for  exec-proc
     al  w1     8
     jl. w3     b9.   ; call exec-proc
     rs. w2     f10.  ; save w2
     dl. w3    (j30.)
     rs  w1 (x2+8)    ; store minprio
     rl. w1     f10.
     rs  w1 (x2+12)   ; store maxprio
     rl  w1     0     ; w1:=startprio
     jl.       (j6.)  ; end intg expr
\f


; exec interface                                       page 6
; integer procedure opmess(textarray,statout)
b. m10 w.
m2:  10
e28: rl. w2    (j13.)
     ds. w3    (j30.) ; saved w3,stack ref
     dl  w1  x2+8     ; check array size
     ea  w1     0
     al  w3     28
     al  w0     0
     sn  w0 (x1)      ; if low index<>1 or
     se  w3 (x1-2)    ; high index<>7 then
     jl.        m4.   ; goto error
     rl  w1 (x2+8)    ; 1.formal:=base addr array
     rs  w1  x2+8
     jl. w1     b2.   ; take 2. param
     rl  w3  x1
     al  w2     0
     rs. w2     f2.   ; set 3 zero chars in converted statout
     sl  w3     0
     sl  w3     999   ; if statout>=0 and statout<999 then
     jl.        m1.
     wd. w3     m2.   ; begin
     al  w2  x2+48    ; convert statout to char
     rs. w2     f2.   ; store 3. digit
     al  w2     0
     wd. w3     m2.
     al  w2  x2+48
     al  w3  x3+48
     ls  w2     8
     ls  w3     16
     wa  w3     4     ; combine 2. and 3. digit
     wa. w3     f2.
     rs. w3     f2.   ; f2:=converted statout
     am        -2
m1:  al  w1     28    ; w1:=hw last word
     dl. w3    (j30.)
     am     (x2+8)    ; last word bits 16:23 :=0
     rl  w0  x1
     ls  w0    -8
     ls  w0     8
     am     (x2+8)
     rs  w0  x1
\f


; exec interface                                       page 7
     rl  w3  x2+8     ; w3:=base textarray
     al. w2     f10.  ; w2:=first textout
m3:  rl  w1  x3+2     ; while word bits 16:23<>0 do
     rs  w1  x2       ; move words
     al  w2  x2+2
     al  w3  x3+2
     sz  w1     255
     jl.        m3.
     al  w1  x1+32    ; last word bits 16:23:=space
     rs  w1  x2-2
     rl. w1     f2.
     rs  w1  x2       ; end up with statout
     al. w0     f10.  ; setup params for exec-proc
     al  w2  x2+2
     al  w1     7
     jl. w3     b9.   ; call exec-proc
     am  w1    -1     ; status:=0
m4:  al  w1     1
     jl.       (j6.)  ; end intg expr
e.


; procedure call_task(ctbl,exctbl,task)
b. m3 w.
e29: rl. w2    (j13.)
     ds. w3    (j30.)
     al  w1    -14
     jl. w3    (j3.)  ; reserve space for ext call
     rs  w2  x1+0
     rl. w0     g1.
     rs  w0  x1+2     ; set return segm tab addr
     al  w3     8
     ls  w3     12
     al  w3  x3+m0
     rs  w3  x1+4     ; set app, rel return
     dl  w0  x2+8     ; move array formals to new stack
     ds  w0  x1+8
     dl  w0  x2+12
     ds  w0  x1+12
     dl  w1  x2+16
     jl.       (j5.)  ; goto point
m0=k-g1
     jl.      e10.    ; goto end task
e.
\f


; exec interface                                       page 8
; subprocedure take param
; call:  w2=stack ref, jl. w1 b<paramno>.
; return w1=addr param, stack(param)=addr param, w0=undef
; w2,w3=stack ref,saved w3
b. m10 w.
m1:  0               ; param
m2:  0               ; return
b1:  am       -4     ; 1. param
b2:  am       -4     ; 2. param
b3:  am       -4     ; 3. param
b4:  al  w0    20    ; 4. param
     rs. w0    m1.   ; save paramno
     rs. w1    m2.   ; save return
     am.      (m1.)
     dl  w1  x2      ; load paramdescr
     so  w0    16
     jl. w3   (j4.)  ; take expr
     ds. w3   (j30.)
     am.      (m1.)
     rs  w1  x2      ; store paramaddr
     jl.      (m2.)
e.

; subroutine call-exec-proc
b9:  am       (66)
     am       (22)   ; get first core addr
     jl       (f9)   ; return to call addr



g4:
c. g4-g1-506
   m. code too big
z.
c. 502-g4+g1, jl -1, r.252-(:g4-g1:)>1 z. ; fill with ill instr.

<:exec intf1<0>:>           ; alarm text

i. e.                         ; end of segment
\f


; exec interface                                       page 9
; tails
g0:                            ; first tail
     1                         ; end task , no of segments
     0,r.4                     ; fill for docname
     1<23 + e10 - e5           ; entry point
     1<18 , 0                  ; procedure
     4<12 + e0 - e5            ; codeproc , start ext. list
     1<12                      ; 1 segment

     1<23 + 4                  ; abort
     0,r.4
     1<23 + e11 - e5
     1<18 , 0
     4<12 + e0 - e5
     1<12

     1<23 + 4                  ; check void
     0,r.4
     1<23 + e12 - e5
     1<18 , 0
     4<12 + e0 - e5
     1<12

     1<23 + 4                  ; logout
     0,r.4
     1<23 + e13 - e5
     1<18 , 0
     4<12 + e0 - e5
     1<12

     1<23 + 4                  ; stop appl
     0,r.4
     1<23 + e14 - e5
     1<18 , 0
     4<12 + e0 - e5
     1<12

     1<23 + 4                  ; split (reschedule)
     0,r.4
     1<23 + e15 - e5
     1<18+19<12,0              ; proc(intg addr)
     4<12 + e0 - e5
     1<12
\f


; exec interface                                       page 10
     1<23 + 4                  ; start alien
     0,r.4
     1<23 + e16 - e5
     3<18+19<12,0              ; intg proc(intg addr)
     4<12 + e0 - e5
     1<12

     1<23 + 4                  ; get excb
     0,r.4
     1<23 + e17 - e5
     3<18+19<12,0
     4<12 + e0 - e5
     1<12

     1<23 + 4                  ; put excb
     0,r.4
     1<23 + e18 - e5
     3<18+19<12,0
     4<12 + e0 - e5
     1<12

     1<23 + 4                  ; write ctbl
     0,r.4
     1<23 + e19 - e5
     3<18+19<12,0
     4<12 + e0 - e5
     1<12
\f


; exec interface                                       page 11

     1<23 + 4                  ; reserve excb
     0,r.4
     1<23 + e23 - e5
     3<18+19<12,0
     4<12 + e0 - e5
     1<12

     1<23 + 4                  ; release excb
     0,r.4
     1<23 + e24 - e5
     3<18+19<12,0
     4<12 + e0 - e5
     1<12

     1<23 + 4                  ; dump
     0,r.4
     1<23 + e25 - e5
     3<18+27<12+19<6+19,19<18  ; intg proc(intg addr,intg addr,intg addr,long array)
     4<12 + e0 - e5
     1<12

     1<23 + 4                  ; write terminal
     0,r.4
     1<23 + e26 - e5
     3<18+19<12+19<6+19,19<18  ; intg proc(intg addr,intg addr,intg addr,intg addr)
     4<12 + e0 - e5
     1<12
\f


; exec interface                                       page 12
     1<23 + 4                  ; priority
     0,r.4 
     1<23 + e27 - e5
     3<18+19<12+19<6,0         ; intg proc(intg addr,intg addr)
     4<12 + e0 - e5
     1<12

     1<23 + 4                  ; opmess
     0,r.4 
     1<23 + e28 - e5
     3<18+19<12+27<6,0         ; intg proc(long array,intg addr)
     4<12 + e0 - e5
     1<12

g1:                            ; last tail
     1<23 + 4                  ; call_task
     0,r.4
     1<23 + e29 - e5
     1<18+31<12+25<6+25,0      ; proc(intg array,intg array,proc)
     4<12 + e0 - e5
     1<12



d. , p.<:insertproc:>
▶EOF◀