2.11BSD/src/games/pdp/zork/o.s
#include <syscall.h>
rti=2
iot=4
nop=240
.data
. = . + 6000
/ this code is actually origined to 0146000
getovr:
jmp reado /jmp to overlay reading routine
getdat:
jmp readd /jmp to file reading routine
chrget:
jmp getchar /jmp to RT-11 .TTYIN emulator
chrput:
jmp putchar /jmp to RT-11 .TTYOUT emulator
printit:
jmp .print /jmp to RT-11 .PRINT emulator
/ setup registers and start pgm where it was interrupted
start:
mov sp,r0
1: tst (r0)+ /calculate environment pointer
bne 1b
tst (r0)+
mov r0,environ /save environment pointer
sys SYS_getuid. /setuid back to user's
mov r0,-(sp)
clr -(sp)
sys SYS_setuid.
sys SYS_getgid.
mov r0,2(sp)
sys SYS_setgid.
cmp (sp)+,(sp)+
clr (sp)
mov $emtvec,-(sp)
mov $7,-(sp) /7 is EMT
mov $sigtramp,-(sp)
tst -(sp)
sys SYS_sigaction. /intercept EMTs
add $10,sp
mov $timval,-(sp)
tst -(sp)
sys SYS_gettimeofday. /get time-of-day
cmp (sp)+,(sp)+
mov hival,otime /save high order
mov lowval,otime+2 /save low order
clr -(sp) /We have to use sigstack
mov sp,sigstk /because 2.10 won't use
mov $sigstk,-(sp) /a signal stack on the
tst -(sp) /normal process stack unless
sys SYS_sigstack. /it's inside the allocated
add $6,sp /stack area.
mov $4,r0
mov $140232,r1
mov $1,r2
mov $140442,r3 /from .SETTOP ??
mov $137724,r4
mov $20670,r5
mov $1102,sp
jmp *$17332
sigtramp:
jsr pc,(r0) /Signal trampoline for sigaction
mov sp,r0
add $6,r0
mov r0,-(sp)
tst -(sp)
sys SYS_sigreturn.
iot
sigstk: 0 /Structure for sigstack call
0
emtvec:
emtrap /interception routine
0; 0 /Bit 6 is EMT (7)
1 /Flag to run on our own signal stack
timval: /Two longs in timeval
hival: 0
lowval: 0; 0; 0
otime: 0; 0 /time at pgm start-up
/ environment pointer
environ: 0
/ file discriptor numbers
ofd: 5 /doveraly open on fd5 (original RT-11 pgm)
ifd: 4 /dindex.dat open on fd4
tfd: 3 /dtext.dat open on fd3
/ disk i/o comes here
reado:
mov ofd,fd /load fd with overaly chan file discrip
br readw /branch to common read routine
readd:
cmp *(sp),$0 /check for chan 0 (dindex.dat)
bne 1f /skip if not
mov ifd,fd /load index file discriptor
br readw
1: cmp *(sp),$1 /check for chan 1 (dtext.dat)
bne 2f /Oh oh!
mov tfd,fd /load text file discriptor
br readw
2: iot /bomb-out with dump
/ read common routine
readw:
mov (sp)+,retaddr /save return address
mov r1,-(sp) /save r1 from mul
mul $512.,r0 /block offset to byte offset
clr -(sp) /offset is from beginning of file
mov r1,-(sp) /store low word of offset on stack
mov r0,-(sp) /and high word at next word on stack
mov (pc)+,-(sp) /put file discriptor on stack
fd: -1 /file discriptor
tst -(sp)
sys SYS_lseek. /seek to proper disk block
add $12,sp /restore stack
mov (sp)+,r1 /restore r1
mov (sp)+,r0 /load address for read
asl (sp) /convert word count to byte count
mov r0,-(sp) /put address on stack
mov fd,-(sp) /load file discriptor on stack
tst -(sp)
sys SYS_read.
add $12,sp /clean-up
jmp *(pc)+ /return
retaddr: -1 /return address
/ character input routine (.TTYIN)
getchar:
mov $1,-(sp) /read 1 character
mov $char,-(sp) /into char
clr -(sp) /read from standard input (0)
tst -(sp)
sys SYS_read. /read 1 character
add $10,sp /clean up
/ special command processing
tst r0 /EOF?
bne 1f /nope
sys SYS_exit. /yup
1:
mov char,r0 /pick-up char
cmp lastch,$'\n /last char a newline?
bne 4f /nope - we're done
cmp r0,$'> /save game?
bne 2f /nope
jsr pc,save
br getchar
2:
cmp r0,$'< /restore game?
bne 3f /nope
jsr pc,restor
br getchar
3:
cmp r0,$'! /escape to UNIX sh?
beq 6f /yes! - go fork
4:
mov r0,(pc)+ /save last char
lastch: '\n
cmp $12,r0 /char a linefeed (newline)?
bne 5f /no
mov $15,r0 /map LF to CR
5:
rts pc /back to dungeon
6:
sys SYS_fork. /fork!
br child /daughter task returns here
/parent returns here
mov r1,-(sp) /protect r1 from wait
clr -(sp) / rusage
clr -(sp) / options
clr -(sp) / status
mov $-1,-(sp) / wpid
tst -(sp) / fake return address
sys SYS_wait4. / wait for daughter to complete
add $5*2,sp
mov (sp)+,r1 /restore r1
mov $3,-(sp) /write prompt when through
mov $prom,-(sp)
mov $1,-(sp)
tst -(sp)
sys SYS_write.
add $10,sp
br getchar /go get more input
prom: <!\n\>> /input prompt characters
.even
/ the following code is run by the daughter task
child:
clr -(sp)
mov $sigdef,-(sp)
mov $2,-(sp) /SIGQUIT
clr -(sp) /no trampoline routine
clr -(sp) /2.11 interface (return @)
sys SYS_sigaction.
add $12,sp
mov environ,-(sp) /set environ pointer
mov $shargs,-(sp)
mov $shname,-(sp)
tst -(sp)
sys SYS_execve. /process "!" command line
add $10,sp
sys SYS_exit.
sigdef:
0; 0; 0; 0
shname: </bin/sh\0>
.even
shargs: sharg0; sharg1; 0
sharg0: <-c\0>
sharg1: <-t\0>
.even
/ save game
save:
tst -(sp)
mov $600,-(sp) /mode
mov $601,-(sp) /O_CREAT|O_TRUNC|O_WRONLY
mov $savfil,-(sp) /path
tst -(sp) /2.11 syscall convention
sys SYS_open. /create output file
bcc 1f /oops
/ this bit of nonsense is needed because 'serr' insists that all syscalls
/ take 10(8) bytes of stack. SYS_open takes 12 so we advance sp by 2 if the
/ open failed. Stuff a -1 in the return value so the check for failure can /
/ be made. Isn't assembly fun?! <grin>.
tst (sp)+
br serr
1:
add $12,sp
mov r0,(pc)+ /save "save" file discriptor
sfd: -1 / "save" file discriptor
mov $17812.,-(sp)
mov $22410,-(sp)
mov r0,-(sp)
tst -(sp)
sys SYS_write. /write out data
bcs rwerr /branch on error
add $10,sp
mov sfd,-(sp) /load "save" file discriptor
tst -(sp)
sys SYS_close. /close "save" file
cmp (sp)+,(sp)+
mov $11.,-(sp)
mov $svmsg,-(sp)
mov $1,-(sp) /load standard output fd
tst -(sp)
sys SYS_write. /convey success
add $10,sp
rts pc /return
svmsg: <Game saved\n> /success message
.even
/ restore game
restor:
tst -(sp)
clr -(sp)
mov $savfil,-(sp)
tst -(sp)
sys SYS_open. /open "save" file
bcs serr /branch on error
add $10,sp
mov r0,sfd /store "save" file fd
mov $17812.,-(sp)
mov $22410,-(sp)
mov r0,-(sp)
tst -(sp)
sys SYS_read. /read data
bcs rwerr /branch on failure
add $10,sp
mov sfd,-(sp) /load "save" file fd
tst -(sp)
sys SYS_close. /close the file
cmp (sp)+,(sp)+
mov $14.,-(sp)
mov $rsmsg,-(sp)
mov $1,-(sp) /load char output fd
sys SYS_write. /report success
add $6,sp
rts pc /return
rsmsg: <Game restored\n>
savfil: <dungeon.dat\0> / "save" file name
.even
/ open, read & write errors come here
rwerr:
mov sfd,-(sp) /close file on read/write error
tst -(sp)
sys SYS_close.
cmp (sp)+,(sp)+
serr:
add $10,sp
mov $7.,-(sp)
mov $ermsg,-(sp)
mov $1,-(sp) /using standard output
tst -(sp)
sys SYS_write. / write "ERROR" message
add $10,sp
rts pc /return (exit for child)
ermsg: <Error\n>
.even
/ RT-11 .TTYOUT emulator
putchar:
mov r0,(pc)+ /save character
char: 0 /char to print
mov $1,-(sp) /write one character
mov $char,-(sp)
mov $1,-(sp) /load terminal output fd
tst -(sp)
sys SYS_write. /write it out
add $10,sp
rts pc /return
/ RT-11 .PRINT emulator
.print:
mov r1,-(sp) /save r1 & r2
mov r2,-(sp)
mov r0,r1 /scan for terminator (right 7 bits 0)
1:
movb (r1)+,r2
bic $177600,r2
bne 1b
/ terminator found
movb -(r1),r2 /save terminator
sub r0,r1 /size of string to output
mov r1,-(sp) /save count
mov r0,-(sp)
mov $1,-(sp) /write to standard output
tst -(sp)
sys SYS_write.
add $10,sp
tstb r2 /skip crlf if 200 bit set in terminator
bmi 2f
mov $2,-(sp)
mov $crlf,-(sp)
mov $1,-(sp)
tst -(sp)
sys SYS_write. /output crlf
add $10,sp
2:
mov (sp)+,r2 /restore registers
mov (sp)+,r1
rts pc
crlf: <\r\n>
.even
emtrap:
mov 6(sp),r0 /Get sigcontext
mov 14(r0),-(sp) /Put old r0 on stack
mov 16(r0),r0 /Pull old pc off stack
cmp $104350,-(r0) /Check for EMT 350
beq .exit /Exit if it is.
cmp $104375,(r0) /if EMT not 375
bne 3f / then abort with dump
mov (sp),r0 /check for .GTIM
cmp $10400,(r0)
bne 1f
tst (r0)+ /bump r0
mov r1,-(sp) /save r1
mov r2,-(sp) /save r2
mov (r0),r2 /get pointer
clr -(sp)
mov $timval,-(sp)
tst -(sp)
sys SYS_gettimeofday. /get current time
add $6,sp
mov lowval,r1
mov hival,r0
sub otime+2,r1 /subtract low order
sbc r0
sub otime,r0 /subtract high order
mov r1,-(sp) /save low order
mul $60,r0 /convert seconds to ticks
mov r1,(r2) /store high order
mov (sp)+,r0 /restore low order
mul $60,r0 /mult low order by 60
mov r1,2(r2) /store low in low order
add r0,(r2) /add high to high
add $6223,2(r2) /add fudge factor
adc (r2)
mov (sp)+,r2 /restore r2 & r1
mov (sp)+,r1
jbr 2f /go return from interrupt
1:
cmp $16000,(r0)+ /check if .GVAL
bne 3f
cmp $300,(r0) /do .GVAL only of 300
bne 3f
mov $121100,(sp) /load fake RT-11 config word
2:
mov (sp)+,r0 /restore r0
rts pc /Return From Interrupt
3:
mov (r0),r1 /Get emt number
bic $177077,r1 /Fix up error message
ash $-6,r1
add $60,r1
movb r1,emt
mov (r0),r1 /Get emt number
bic $177707,r1 /Fix up error message
ash $-3,r1
add $60,r1
movb r1,emt+1
mov (r0),r1 /Get emt number
bic $177770,r1 /Fix up error message
add $60,r1
movb r1,emt+2
jsr pc,save /save game before blow-up
mov $core62,-(sp)
tst -(sp)
sys SYS_chdir. /put core dump in special place
cmp (sp)+,(sp)+
mov $29.,-(sp) /Write an explaination out
mov $emtmsg,-(sp)
mov $1,-(sp)
tst -(sp)
sys SYS_write.
add $10,sp
mov (sp)+,r0 /restore r0
rts pc /return
emtmsg:
<A vicious emt >
emt: <xxx>
< kills you.\n>
core62:
</usr/games/lib/coredumps\0>
.even
/.EXIT emulator with a minor cleanup
.exit:
mov $2,-(sp)
mov $crlf,-(sp)
mov $1,-(sp)
tst -(sp)
sys SYS_write.
sys SYS_exit.