glm94/pdp7-unix
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

resolved conflict

Browse Source
This commit is contained in:
Will Senn
2016-03-01 10:18:55 -06:00
parent 4914fc5dc8 2af2802335
commit 55e638c9fb
19 changed files with 1583 additions and 869 deletions
Download Patch File Download Diff File Expand all files Collapse all files
misc/asm_syntax.txt
+254 -23
View File
@@ -1,42 +1,273 @@
Basics of the Unix assembler syntax
Basics of the "Unix v0" 'as' assembler syntax and PDP-7 coding:
Lines starting with " are comment lines
ASSEMBLER SYNTAX:
=================
Anything from " to end of line is a comment.
. is the location counter, where the next code or constant will be placed
.. is the relocation counter
.. is the relocation counter (not currently handled)
t = 0 Sets a built-in variable to this value without generating any machine code.
Variables so far are . .. and t. Not sure what t's purpose is yet.
Symbol names start with a letter, and can contain letters and "."
The dump of label values in "scans/sysmap" appears to show truncation
after 8 characters (not currently enforced by the "as7" Perl script).
orig: is a label. It looks like labels can have dots in them.
Dots seem to separate structures and fields, e.g. u.base
but there are some symbols that start with dots, e.g. .seek
symbol = expression
jms copy; 10; u.rg+2; 6 Semicolons separate instructions and
word expressions that follow the instruction
Sets a built-in variable to this value without generating any
machine code.
Some expressions are 0:0, not sure about this.
Is it two 9-bit fields? No idea
as7 enters machine instructions and the indirect bit (i)
into the variable table.
jmp 1f Jump back to the closest 1: label
jmp 1b Jump forward to the closest 1: label
label: is a label.
Some lines are indented differently to others e.g.
single digit decimal numbers can be used as "local" labels,
which are referenced with Nf and Nb:
jms betwen; o10000; o17762
jms error
dac .+1
jmp 1f Jump back to the closest 1: label
jmp 1b Jump forward to the closest 1: label
I think this is to indicate the skip logic, but it plays no part in the assembly syntax.
-1 occurs instead of instructions, so it looks like the assembler allows
literal constants at any time.
multiple words can be entered on one line, separated by semi-colon.
String literals seem to be two characters decorated with < > characters, e.g.
"ab" is <a>b. I'm guessing these are placed as pairs in one word. The syntax
is confusing, because I've also seen <no> ; 040 ; <fi> ; <le>; <s 012 which
appears to mean "no files\n".
Looks like a line can contain multiple labels, e.g. o12: d10: 10
A line can contain multiple labels, e.g. o12: d10: 10
Numeric literals: 0xx are octal values, [1-9]xx are decimal values.
CONVENTIONS:
============
Because there is no immediate mode (and "as" lacks the literal syntax
found in DEC assemblers), there is a convention for literal (manifest)
constants:
dNNN indicates the location of a constant for decimal NNN.
oOOO for octal constant OOO.
dmN (decimal minus) indicates a constant for decimal -N.
High order bits of the "law" (load ac with word) instruction are all
ones, so "-1" as an instruction loads -1 into AC.
Subroutine arguments are often located in the words following the
call. When an argument is a variable, sometimes a "0:" local label is
used to tag the location:
jms namei; 0:0
Indentation is (sometimes) used to indicate an instruction
or subroutine that may skip:
jms betwen; o10000; o17762
jms error
dac .+1
NOTE! the "betwen" (between) routine (which appears in multiple
places) takes ADDRESSES of values (which can be literals, as above),
or could be symbol names for variables.
I haven't seen any cases where "skip chains" (sequences of skip
instructions) are indicated by multiple indents.
There is no hardware stack, so the only form of subroutine call (jms)
is "impure" and leaves the (updated) program counter in the first word
of the subroutine, and execution starts on the second word.
Routines which fetch arguments from after the jms instruction may do:
routine: 0
lac routine i " pick up argument after jms
dac temp " store in temp location
isz routine " increment return PC to skip argument
Routines which (optionally) skip (eg; on success) may use "isz
routine" to (conditionally) increment the return PC.
In the system code t is used as a (current) offset into a block of
temporary location(s) for a routine or group of routines , at label
9f, so you'll see:
this:
0
lac 9f+t+N
....
t=t+M
....
that:
0
lac 9f+t+I
....
t=t+J
.....
.....
.....
9f:
.=.+t
HARDWARE:
=========
References:
http://simh.trailing-edge.com/docs/architecture18b.pdf
http://www.soemtron.org/pdp7.html
http://www.soemtron.org/pdp7history.html
NOTE! All opcodes are defined in "sop.s" (and in "as7") and are
commented as below.
The PDP-4/7/9/15 family started as a simplified version of the PDP-1,
(itself an evolution of the TX-0, designed at MIT Lincoln Labs). The
PDP-4 wasn't very successful (offering 5/8 PDP-1 performance at 1/2
the price).
The PDP-7 was originally concieved of as a repackaging of the PDP-1,
but DEC had a built up more system software for the PDP-4 than for the
PDP-1 (including a FORTRAN II compiler!), so they continued with the
new architecture. See Bob's paper (first link above) for more detail.
The Living Computing Museum in Seattle has a running PDP-7, and
intends to build simulated disk hardware to enable running "Unix v0".
Words are 18 bits, words are typically represented as six octal digits.
There is one 18 bit accumulator, called "AC".
The "LINK" register is a 1-bit register that is included in shifts.
The Extended Arithmetic Element (EAE) option adds an "MQ" register which
has limited uses.
Bit numbering is "big endian": bit zero is 400000.
There are no "addressing" modes: memory referencing instructions,
(opcodes 0 thru 060) decode the low 14 bits as:
I (020000) "indirect" bit
Y (017777) 13-bit address field.
When the "I" bit is clear, the "Y" field is the address of the operand.
When the "I" bit is set, the word referenced by the contents of the
word addressed by "Y" field is used as the operand.
Unlike the PDP-1 (and PDP-6/10) indirect references are not
multi-level, and end after the first indirect fetch.
The PDP-7 found by Ken Thompson apparently did not have extended
memory or memory protection options and could directly reference all
8K words of memory (at all times).
Unix system code appears to have resided in the low 4K of memory, and
a single user program in the high 4K. The system had a "fast"
fixed-head disk, but indirect memory access locks out DMA by the disk
controller, and indirect access cannot be used while disk transfers
are active (the interrupt service routines for clock and TTY, are
coded without using indirect!). Because of this, disk access cannot
be "overlapped" with user code, but users are free to use "indirect"
freely.
When locations 010 through 017 of memory are referenced *INDIRECTLY*,
they auto-increment after access, and can be used as "index
registers".
System calls are made using the "CAL" (call) instruction (octal 00).
The Y field indicates the system call number. "CAL" behaves like "jms
020". "CAL" with the "I" bit set behaves like "jms 20 i". The system
handler appears to deal with both (although the non-indirect form
destroys the contents of location 020), and has a longer code path, so
it seems likely that "sys=cal i" became the preferred system call at
some point?
The kernel preserves the contents of the users' AC and MQ registers
and locations 8-15 in the "userdata" block (symbols u.ac, u.mq and
u.rq). Location u.rq+8 is the saved PC of the last system call.
The "save" system call (and any undefined system call) write high 4K
of memory and the "userdata" block (to fd 1?????)
The system did not have advanced interrupt processing hardware, so all
"priority interrupts" (also known in the past as "address break"
processing) dispatched as if a "jms 0" was executed, and are processed
in the "pibreak" routine.
Summary of memory instructions (from annotated sop.s):
dac = 0040000 " MEM: deposit AC
jms = 0100000 " MEM: jump to subroutine
dzm = 0140000 " MEM: deposit zero to memory
lac = 0200000 " MEM: load AC
xor = 0240000 " MEM: XOR with AC
add = 0300000 " MEM: one's complement add
tad = 0340000 " MEM: two's complement add
xct = 0400000 " MEM: execute
isz = 0440000 " MEM: increment and skip if zero
and = 0500000 " MEM: AND with memory
sad = 0540000 " MEM: skip if AC different
jmp = 0600000 " MEM: jump
Other instruction groups do not interpret the "I" bit, and all begin
with '7' in the high three bits.
I/O Transfer (or IOT) have 111000 (070) in the high six bits. the next
six bits (two octal digits) indicate the device number.
Operate (OPR) which is "microcoded" with low order bits indicating
"micro operations" to be performed have 11110 (074) in the high four
bits:
cma = 0740001 " OPR: complement AC
ral = 0740010 " OPR: rotate AC left
rar = 0740020 " OPR: rotate AC right
hlt = 0740040 " OPR: halt
sma = 0740100 " OPR: skip on minus AC
sza = 0740200 " OPR: skip on zero AC
snl = 0740400 " OPR: skip on non-zero link
skp = 0741000 " OPR: skip unconditionally
sna = 0741200 " OPR: skip on negative AC
szl = 0741400 " OPR: skip on zero link
rtl = 0742010 " OPR: rotate two left
rtr = 0742020 " OPR: rotate two right
cll = 0744000 " OPR: clear link
rcl = 0744010 " OPR: clear link, rotate left
rcr = 0744020 " OPR: clear link, rotate right
cla = 0750000 " OPR: clear AC
las = 0750004 " OPR: load AC from switches
With some limitations, OPR instructions can be OR-ed together.
(Ordering of operations is determined by the hardware, not by their
order in the source!!):
sna cla " skip on negative AC, clear AC
sna spa " skip on negative or positive AC
sna ral " skip on negative AC, rotate AC left
cla cll sza " skip on AC zero, clear AC, clear LINK
The last "operate" instruction is not microcoded:
law = 0760000 " OPR: load accumulator with (instr)
and as noted above, is often coded directly as an immediate negative constant.
Unix v0 depends on the EAE option, which uses instructions with 064 in
the top four bits, and is used for multiply, divide, and the 18-bit MQ
register:
lrs = 0640500 " EAE: long right shift
lrss = 0660500 " EAE: long right shift, signed
lls = 0640600 " EAE: long left shift
llss = 0660600 " EAE: long left shift, signed
als = 0640700 " EAE: AC left shift
alss = 0660700 " EAE: AC left shift, signed
mul = 0653323 " EAE: multiply
idiv = 0653323 " EAE: integer divide
lacq = 0641002 " EAE: load AC with MQ
clq = 0650000 " EAE: clear MQ
omq = 0650002 " EAE: OR MQ into AC
cmq = 0650004 " EAE: complement MQ
lmq = 0652000 " EAE: load MQ from AC
scans/Readme
+1 -1
View File
@@ -46,7 +46,7 @@ init.s pages 47-51 of 07-13-19.pdf
cas.s: pages 1-17 of 04-cas.pdf
ind.b: page 2 of 08-rest.pdf
lease.b: page 4 of 08-rest.pdf
lcase.b: page 4 of 08-rest.pdf
adm.s pages 2-11 of 05-1-4.pdf
ald.s pages 13-17 of 05-1-4.pdf
scans/as.s
+8 -8
View File
@@ -211,7 +211,7 @@ proc1:
jmp proc2
jms bufwr
jms copyz; buf; 64
lac lyrand
lac lvrand
and o17700
dac bufadd
dac 1f
@@ -277,7 +277,7 @@ bufwr: 0
lacq
tad o60
dac i 8
iac 2b
lac 2b
cll
idiv; 10
lacq
@@ -454,7 +454,7 @@ nf1:
lac fname
tad d4
dac fname
sys open; frame: 0; 0
sys open; fname: 0; 0
dac iof
sma
lac passno
@@ -513,7 +513,7 @@ gchar: 0
gch3:
dac char
jms betwn; d0; o200
jms betwen; d0; o200
cla
tad lactab
dac .+1
@@ -814,12 +814,12 @@ exp2:
dac srand
lac r+1
dac srand+1
jmp expb
jmp exp5
exp3:
sad d5
jmp exp4
jms error; x>
smp skip
jmp skip
exp4:
jms pickup
jmp i expr
@@ -939,7 +939,7 @@ o74: 074
o76: 076
namsiz: -2
namistp: namlst
namlstp: namlst
fnamep: fakename
lactab: lac .+1
8;8;8;8;8;8;8;8
@@ -993,4 +993,4 @@ namlst:
"** 05-1-4.pdf page 48
dot:
.=.+6
cmflx:
cmflx:
src/cmd/lease.b → scans/lcase.b
View File
scans/s1.s
+2 -2
View File
@@ -53,7 +53,7 @@ orig:
jms halt
okexit:
dzm: u.ac
dzm u.ac
sysexit:
ion
lac .savblk
@@ -72,7 +72,7 @@ sysexit:
dac 9
lac u.rq
dac 8
lac u.rq
lac u.mq
lmq
lac u.ac
jmp u.rq+8 i
scans/trysys.s
+1 -1
View File
@@ -32,7 +32,7 @@ error:
1: 077012
a.out:
<a.>;<ou><t 040; 040040
<a.>;<ou>;<t 040; 040040
t1: 0
t2: 0
c1: 0
src/cmd/as.s
+483 -441
View File
File diff suppressed because it is too large Load Diff
src/cmd/cat.s
+66 -64
View File
@@ -10,17 +10,17 @@
dac name
loop:
sys open; name:0; 0; " Open file, get fd back
sys open; name:0; 0 " Open file, get fd back
spa
jmp badfile " Negative fd, exit with an error message
dac fi " save file descriptor in fi
dac fi " Save file descriptor in fi
1:
jms getc " get a character in AC
jms getc " Get a character in AC
sad o4
jmp 1f
jms putc " write the character on stdout
jmp 1b
jmp 1f " Break the loop when we get a ctrl-D
jms putc " Write the character on stdout
jmp 1b " and loop back
1:
lac fi " Close the file descriptor in fi
@@ -57,93 +57,95 @@ nofiles:
1: <no>; 040; <fi>;<le>;<s 012
done:
lac noc
lac noc " Is the number of characters left zero?
sna
sys exit
sys exit " Yes, exit
and d1
sna cla
jmp 1f
jms putc
jmp done
jms putc " Store the character in the buffer
jmp done " and loop back
1:
lac noc
rcr
dac 1f
lac noc " Get the number of characters in the buffer
rcr " Divide by two to convert to words
dac 1f " Save in the write's word count below
lac fo " Load fd 1, stdout
sys write; iopt+1; 1
sys write; iopt+1; 1:.. " Write the leftover buffer and exit
sys exit
getc: 0
lac ipt
lac ipt " Load the pointer to the next word in the buffer
sad eipt
jmp 1f
dac 2f
add o400000
jmp 1f " We've reached the end of the buffer, so read more
dac 2f " Save the pointer
add o400000 " Flip the msb and save into ipt
dac ipt
ral
lac 2f i
szl
lrss 9
and o177 " keep the lowest 7 bits
ral " Move the msb into the link register
lac 2f i " Load the word from the buffer
szl " Skip if this is the second character in the word
lrss 9 " It's the first char, shift down the top character
and o177 " Keep the lowest 7 bits
sna
jmp getc+1
jmp getc i " return from subroutine
jmp getc+1 " Skip a NUL characters and read another one
jmp getc i " Return the character from the subroutine
1:
lac fi
lac fi " Buffer is empty, read another 64 characters
sys read; iipt+1; 64
sna
jmp 1f
tad iipt
dac eipt
lac iipt
jmp 1f " No characters were read in
tad iipt " Add the word count to the base of the buffer
dac eipt " and store in the end buffer pointer
lac iipt " Reset the ipt to the base of the buffer
dac ipt
jmp getc+1
jmp getc+1 " and loop back to get one character
1:
lac o4
lac o4 " No character, return with ctrl-D
jmp getc i " return from subroutine
putc: 0
and o177 " keep the lowest 7 bits
and o177 " Keep the lowest 7 bits and save into 2f+1
dac 2f+1
lac opt
dac 2f
add o400000
dac opt
spa
jmp 1f
lac 2f i
lac opt " Save the pointer to the empty buffer
dac 2f " position to 2f
add o400000 " Flip the msb and save back into opt
dac opt " This also has the effect of incrementing
" the opt pointer every second addition!
spa " If the bit was set, we already have one
jmp 1f " character at 2f+1. If no previous character,
lac 2f i " merge the old and new character together
xor 2f+1
jmp 3f
jmp 3f " and go to the "save it in buffer" code
1:
lac 2f+1
lac 2f+1 " Move the character up into the top half
alss 9
3:
dac 2f i
isz noc
lac noc
dac 2f i " Save the word into the buffer
isz noc " Add 1 to the char count, never skipping
lac noc " Have we reached 128 characters, 64 words?
sad d128
skp
jmp putc i
lac fo " load fd 1, stdout
sys write; iopt+1; 64
jmp putc i " No, so return (more room still in the buffer)
lac fo " Load fd1 (i.e stdout)
sys write; iopt+1; 64 " and write out the 64 words in the buffer
lac iopt
dac opt
dzm noc
jmp putc i
dac opt " Set opt pointing back to base of buffer
dzm noc " Set the number of chars in the buffer to 0
jmp putc i " and return
2: 0;0
ipt: 0
eipt: 0
iipt: .+1; .=.+64 " 64 word input buffer
fi: 0
opt: .+2
iopt: .+1; .=.+64 " 64 word output buffer
noc: 0
fo: 1 " output file descriptor, fd 1 is stdout
2: 0;0 " Current input and output word pointers
ipt: 0 " Current input buffer base
eipt: 0 " Pointer to end of data read in input buffer
iipt: .+1; .=.+64 " 64 word input buffer and pointer to it
fi: 0 " Input file descriptor
opt: .+2 " Current output buffer base
iopt: .+1; .=.+64 " 64 word output buffer and pointer to it
noc: 0 " Number of output characters
fo: 1 " Output file descriptor, fd 1 is stdout
d1: 1 " octal and decimal constants
d1: 1 " Octal and decimal constants
o4:d4: 4
d8: 8
o400000: 0400000
o177: 0177
d128: 128
o400000: 0400000 " Msb toggle bit
o177: 0177 " ASCII mask
d128: 128 " 128 words in the output buffer
scans/lease.b → src/cmd/lcase.b
View File
src/other/wktcat.s
+105
View File
@@ -0,0 +1,105 @@
" Warren's cat program: cat [arg1 arg2 ...]
main:
" Load the pointer pointer in 017777 to see if we have any arguments
lac 017777 i
sad d4 " Skip if we have more than four argument words
jmp stdinout " Only four argument words, so no arguments
lac 017777 " Move five words past the argument word count
tad d1 " so that AC points at the first argument
tad d4
" This section opens files and copies their contents to standard output
catfiles:
" We start with AC pointing to an argument. Save it at the "name" label
dac name
" Open the file and get the fd into AC
sys open; name:0; 0;
spa
jmp badfile " Negative fd, exit with an error message
dac fd " Save the file descriptor
fileloop:
" Read 64 words into the buffer from the input file
lac fd
sys read; buf; 64
spa " Skip if result was >= 0
jmp error " Result was -ve, so error result
sna " Skip if result was >0
jmp fileend " Result was zero, so nothing left to read
" Save the count of words read in
dac 1f
" Write five words from the buffer to stdout
lac d1
sys write; buf; 1:0
" and loop back for more words to read
jmp fileloop
fileend:
" Close the open file descriptor
lac fd
sys close
" Subtract 4 from the count of argument words
-4
tad 017777 i
dac 017777 i
sad d4 " Is the value 4, i.e. no args left?
jmp end " Yes, so exit
" Still an argument, so move up to the next filename argument
lac name
tad d4
dac name
jmp catfiles " and loop back to cat this file
end:
" exit
sys exit
" This section copies from standard input to standard output
" We cheat by setting the fd value to zero and storing 8
" into the argc word count, so that when the code hits
" fileend, the word count drops to 4 and we exit.
stdinout:
lac d8
dac 017777 i " Save 8 into the word count
lac d0
dac fd " Save file descriptor 0
jmp fileloop
" This code comes from the real cat.s
badfile:
lac name " Get the pointer to the filename
dac 1f " Store it in 1f below
lac d8 " Load fd 8 which is stderr
sys write; 1:0; 4 " Write the name, max 4 words
lac d8 " Then write " ?\n"
sys write; 1f; 2
sys exit " and exit
1: 040; 077012 " String literal: " ?\n"
error:
" Print an "err read" string on stderr and exit
lac d8
sys write; noreadstr; 5
sys exit
noreadstr:
<er>;<r 040;<re>;<ad>;012000
fd: 0 " fd of the open file
d0: 0 " Constants 0, 1, 4 and 8
d1: 1
d4: 4
d8: 8 " stderr seems to have fd 8
minus4: 0777774 " Constant -4
" Input buffer for read
buf: .=.+64
src/other/wktcp.s
+110
View File
@@ -0,0 +1,110 @@
" Warren's cp program: cp arg1 arg2
main:
" Load the pointer pointer in 017777 to see if we have any arguments
lac 017777 i
sad d12
jmp 1f " We have 12 words, so we have 2 arguments
jmp argserror " Otherwise, print an error and exit
1: lac 017777 " Move five words past the argument word count
tad d5 " so that AC points at the first argument
" Save the pointer to the file name
dac name
" Open the input file and get the fd into AC
sys open; name:0; 0;
spa
jmp badfile " Negative fd, exit with an error message
dac infd " Save the file descriptor
lac 017777 " Move nine words past the argument word count
tad d9 " so that AC points at the second argument
dac name
dac name2
" Open the ouput file and get the fd into AC
sys open; name2:0; 1;
spa
jmp badfile " Negative fd, exit with an error message
dac outfd " Save the file descriptor
fileloop:
" Read 64 words into the buffer from the input file
lac infd
sys read; buf; 64
spa " Skip if result was >= 0
jmp readerror " Result was -ve, so error result
sna " Skip if result was >0
jmp fileend " Result was zero, so nothing left to read
" Save the count of words read in
dac 1f
" Write five words from the buffer to the output file
lac outfd
sys write; buf; 1:0
spa " Skip if result was >= 0
jmp writeerror " Result was -ve, so error result
" and loop back for more words to read
jmp fileloop
fileend:
" Close the open file descriptors
lac infd
sys close
lac outfd
sys close
sys exit
" This code comes from the real cat.s
badfile:
lac name " Get the pointer to the filename
dac 1f " Store it in 1f below
lac d8 " Load fd 8 which is stderr
sys write; 1:0; 4 " Write the name, max 4 words
lac d8 " Then write " ?\n"
sys write; 1f; 2
sys exit " and exit
1: 040; 077012 " String literal: " ?\n"
readerror:
" Print an "err read" string on stderr and exit
lac d8
sys write; noreadstr; 5
sys exit
noreadstr:
<er>;<r 040;<re>;<ad>;012000
writeerror:
" Print an "err write" string on stderr and exit
lac d8
sys write; nowritestr; 6
sys exit
nowritestr:
<er>;<r 040;<wr>;<it>;<e 012
argserror:
" Print an "bad args" string on stderr and exit
lac d8
sys write; badargs; 5
sys exit
badargs:
<ba>;<d 040;<ar>;<gs>;012000
infd: 0 " fd of the input file
outfd: 0 " fd of the output file
d5: 5
d9: 9
d8: 8 " stderr seems to have fd 8
d12: 12
" Input buffer for read
buf: .=.+64
src/other/write_test.s
+61
View File
@@ -0,0 +1,61 @@
" Test program for several system calls: open, read, write, close, exit
" Do:
" ./as7 write_test.s > a.out
" ./a7out -d a.out
main:
" Test the lac, dac instructions
lac in
dac out
" Write hello to fd1 i.e stdout
lac d1
sys write; hello; 7
" Test if the assembler can dac into a mid-line label
lac helloptr
dac 1f
lac d1
sys write; 1:0; 7
" Try to open file fred
sys open; fred; 0;
" read 5 words into the buffer from stdin: type in 10 or more characters!
lac d0
sys read; buf; 5
" Stop and dump memory, so you can see five words at location 0400
" Comment out the hlt instruction to test close and exit
hlt
" close stdin
lac d0
sys close
" exit
sys exit
" We should not get to the halt instruction
hlt
" Some memory locations for lac and dac
. = 0100
in: 023
. = 0200
out: 0
" Hello, world\n, two ASCII chars per word
hello: <He>; <l 0154; 0157 ,>; 040; <wo>; <rl>; <d 012
helloptr: hello
" fred as a four word filename
fred: <fr>; <ed>; 040040; 040040
" Input buffer for read
. = 0400
buf: 0
d0: 0
d1: 1
src/sys/s1.s
+43 -43
View File
@@ -21,61 +21,61 @@ orig:
jmp 1f+1
1f
1: 0
iof
dac u.ac
iof " interrupts off
dac u.ac " save user AC
lacq
dac u.mq
dac u.mq " save user MQ
lac 8
dac u.rq
dac u.rq " save user auto-index location 8
lac 9
dac u.rq+1
jms copy; 10; u.rq+2; 6
lac 1b
dac u.rq+8
dac u.rq+1 " save user auto-index location 9
jms copy; 10; u.rq+2; 6 " save user auto-index locations 10-15
lac 1b " load user PC after system call
dac u.rq+8 " save user PC
-1 " load -1
dac .savblk " set "save" flag (cleared by disk I/O?)
dac .insys " set "in system" flag
lac uquant " load user quantum count
jms betwen; d0; maxquant " check if between 0 & maxquant??
jms swap " no: swap processes
ion " interrupts on
-1
dac .savblk
dac .insys
lac uquant
jms betwen; d0; maxquant
jms swap
ion
-1
tad u.rq+8
jms laci
jms betwen; o20001; swn
jmp badcal
tad swp
dac .+1
jmp .. i
tad u.rq+8 " get address of system call
jms laci " load AC indirect??
jms betwen; o20001; swn " range check
jmp badcal " bad system call
tad swp " add system call table base
dac .+1 " save as next instruction
jmp .. i " dispatch system call
. = orig+0100
jmp coldentry
jms halt
okexit:
dzm: u.ac
sysexit:
ion
lac .savblk
sza
jmp 1f
jms copy; sysdata; dskbuf; 64
dzm u.ac " 'OK' system call exit: clear user AC
sysexit: " common system call exit code
ion " enable interrupts
lac .savblk " load "save" flag
sza " is zero (cleared by disk I/O)?
jmp 1f " no: no disk I/O done?
jms copy; sysdata; dskbuf; 64 " copy system data to disk buffer
cla
jms dskio; 07000
jms dskio; 07000 " save to disk?
1:
dzm .insys
dzm .insys " clear "in system call" flag
jms chkint
skp
jmp .save
jms copy; u.rq+2; 10; 6
lac u.rq+1
jmp .save " dump core??
jms copy; u.rq+2; 10; 6 " restore auto-index locations 10-15
lac u.rq+1 " restore auto-index location 9
dac 9
lac u.rq
lac u.rq " restore auto-index location 8
dac 8
lac u.rq
lac u.mq " restore MQ register
lmq
lac u.ac
jmp u.rq+8 i
lac u.ac " restore AC register
jmp u.rq+8 i " return to user
swap: 0
ion
@@ -129,21 +129,21 @@ swap: 0
jmp swap i
t = t+1
swp:
jmp .
swp: " system call dispatch table
jmp . " base instruction
.save; .getuid; .open; .read; .write; .creat; .seek; .tell
.close; .link; .unlink; .setuid; .rename; .exit; .time; .intrp
.chdir; .chmod; .chown; badcal; .sysloc; badcal; .capt; .rele
.status; badcal; .smes; .rmes; .fork
swn:
.-swp-1 i
.-swp-1 i " count of system calls, plus indirect!
.intrp:
lac u.ac
dac u.intflg
jmp okexit
.sysloc:
.sysloc: " "sysloc": syscall to return system addresses
lac u.ac
and o17777
jms betwen; d1; locn
@@ -154,7 +154,7 @@ swn:
dac u.ac
jmp sysexit
locsw:
locsw: " table of system data structures for "sysloc" call
lac .
iget; inode; userdata; sysdata; copy; copyz; betwen; dskrd
dskwr; dskbuf; dpdata; namei; pbsflgs; alloc; free; dspdata
src/sys/s2.s
+15 -12
View File
@@ -53,9 +53,9 @@
jms iput
jmp okexit
.getuid:
.getuid: " getuid system call
lac u.uid
dac u.ac
dac u.ac " return u.uid in user AC
jmp sysexit
.seek:
@@ -146,12 +146,12 @@
jms iput
jmp sysexit
.setuid:
lac u.uid
sma
jms error
lac u.ac
dac u.uid
.setuid: " setuid system call
lac u.uid " load current user id
sma " negative?
jms error " no: error!!
lac u.ac " load user AC
dac u.uid " save as new uid
jmp sysexit
.rename:
@@ -168,11 +168,14 @@
jms copy; 1:0; d.name; 4
jmp okexit
" time system call returns line (mains) frequency ticks since boot?
" note: returns uptime!?
" at 60Hz, 36 bits would last 36+ years!
.time:
lac s.tim
dac u.ac
lac s.tim+1
dac u.mq
lac s.tim " load high order bits
dac u.ac " return in AC
lac s.tim+1 " load low order bits
dac u.mq " return in MQ
jmp sysexit
.chdir:
src/sys/s7.s
+9 -9
View File
@@ -1,7 +1,7 @@
"** 01-s1.pdf page 41
" s7
pibreak:
pibreak: " priority interrupt processing "chain"
dac .ac "** CROSSED OUT....
dpsf
@@ -25,15 +25,15 @@ pibreak:
dac dpwrite
jmp piret "** END OF CROSSOUT
1: clsf
jmp 1f
1: clsf " clock overflow (line frequency ticks)?
jmp 1f " no
lpb
dac pbsflgs
isz s.tim+1
skp
isz s.tim
isz uquant
lpb " load display push buttons
dac pbsflgs " save
isz s.tim+1 " increment low order tick count
skp " no overflow, skip second increment
isz s.tim " low order overflowed, increment high order count
isz uquant " increment user quantum counter
"** written: ttydelay -> ttyd1
"** written: ttyrestart -> ttyres1
cnop:
src/sys/sop.s
+89 -91
View File
@@ -1,97 +1,95 @@
"** 01-s1.pdf page 62
" sop
dac = 0040000
jms = 0100000
dzm = 0140000
lac = 0200000
xor = 0240000
add = 0300000
tad = 0340000
xct = 0400000
isz = 0440000
and = 0500000
sad = 0540000
jmp = 0600000
nop = 0740000
i = 020000
law = 0760000
cma = 0740001
las = 0750004
ral = 0740010
rar = 0740020
hlt = 0740040
sma = 0740100
sza = 0740200
snl = 0740400
skp = 0741000
sna = 0741200
szl = 0741400
rtl = 0742010
rtr = 0742020
cil = 0744000
rcl = 0744010
rcr = 0744020
cia = 0750000
lrs = 0640500
lrss = 0660500
lls = 0640600
llss = 0660600
als = 0640700
alss = 0660700
mul = 0653323
idiv = 0653323
lacq = 0641002
clq = 0650000
omq = 0650002
cmq = 0650004
lmq = 0652000
dac = 0040000 " MEM: deposit AC
jms = 0100000 " MEM: jump to subroutine
dzm = 0140000 " MEM: deposit zero to memory
lac = 0200000 " MEM: load AC
xor = 0240000 " MEM: XOR with AC
add = 0300000 " MEM: one's complement add
tad = 0340000 " MEM: two's complement add
xct = 0400000 " MEM: execute
isz = 0440000 " MEM: increment and skip if zero
and = 0500000 " MEM: AND
sad = 0540000 " MEM: skip if AC different
jmp = 0600000 " MEM: jump
nop = 0740000 " OPR: no-op
i = 020000 " indirect
law = 0760000 " OPR: load accumulator with (instr)
cma = 0740001 " OPR: complement AC
las = 0750004 " OPR: load AC from switches
ral = 0740010 " OPR: rotate AC left
rar = 0740020 " OPR: rotate AC right
hlt = 0740040 " OPR: halt
sma = 0740100 " OPR: skip on minus AC
sza = 0740200 " OPR: skip on zero AC
snl = 0740400 " OPR: skip on non-zero link
skp = 0741000 " OPR: skip unconditionally
sna = 0741200 " OPR: skip on non-zero AC
szl = 0741400 " OPR: skip on zero link
rtl = 0742010 " OPR: rotate two left
rtr = 0742020 " OPR: rotate two right
cll = 0744000 " OPR: clear link
rcl = 0744010 " OPR: clear link, rotate left
rcr = 0744020 " OPR: clear link, rotate right
cla = 0750000 " OPR: clear AC
lrs = 0640500 " EAE: long right shift
lrss = 0660500 " EAE: long right shift, signed
lls = 0640600 " EAE: long left shift
llss = 0660600 " EAE: long left shift, signed
als = 0640700 " EAE: AC left shift
alss = 0660700 " EAE: AC left shift, signed
mul = 0653323 " EAE: multiply
idiv = 0653323 " EAE: integer divide
lacq = 0641002 " EAE: load AC with MQ
clq = 0650000 " EAE: clear MQ
omq = 0650002 " EAE: OR MQ into AC
cmq = 0650004 " EAE: complement MQ
lmq = 0652000 " EAE: load MQ from AC
dscs = 0707141
dslw = 0707124
dslm = 0707142
dsld = 0707104
dsls = 0707144
dssf = 0707121
dsrs = 0707132
iof = 0700002
ion = 0700042
caf = 0703302
clon = 0700044
clsf = 0700001
dscs = 0707141 " DSK: clear status register
dslw = 0707124 " DSK: clear and load WC from AC
dslm = 0707142 " DSK: clear and load MAC from AC
dsld = 0707104 " DSK: clear and load TA and SA from AC
dsls = 0707144 " DSK: load status
dssf = 0707121 " DSK: skip on flags
dsrs = 0707132 " DSK: read status register
iof = 0700002 " PIC: interrupts off
ion = 0700042 " PIC: interrupts on
caf = 0703302 " CPU: clear all flags
clon = 0700044 " CLK: clear flag, enable
clsf = 0700001 " CLK: skip if overflow
"** 01-s1.pdf page 63
clof = 0700004
ksf = 0700301
krb = 0700312
tsf = 0700401
tcf = 0700402
tls = 0700406
sck = 0704301
cck = 0704304
lck = 0704312
rsf = 0700101
rsa = 0700104
rrb = 0700112
psf = 0700201
pcf = 0700202
psa = 0700204
cdf = 0700501
lds = 0701052
lda = 0701012
wcga = 0704206
raef = 0700742
rlpd = 0700723
beg = 0700547
spb = 0704401
cpb = 0704404
lpb = 0704412
wbl = 0704424
dprs = 0704752
dpsf = 0704741
dpcf = 0704761
dprc = 0704712
crsf = 0706701
crrb = 0706712
clof = 0700004 " CLK: clear flag, disable
ksf = 0700301 " KBD: skip if flag set
krb = 0700312 " KBD: read buffer
tsf = 0700401 " TTY: skip if flag set
tcf = 0700402 " TTY: clear flag
tls = 0700406 " TTY: load buffer, select
sck = 0704301 " S-2: skip on console keyboard
cck = 0704304 " S-2: clear console keyboard
lck = 0704312 " S-2: load console keyboard
rsf = 0700101 " PTR: skip if flag set
rsa = 0700104 " PTR: select alphanumeric mode
rrb = 0700112 " PTR: clear flag, or read buffer
psf = 0700201 " PTP: skip if flag set
pcf = 0700202 " PTP: clear flag
psa = 0700204 " PTP: alphanumeric mode
cdf = 0700501 " ???
lds = 0701052 " S-2: load display status
lda = 0701012 " S-2: load display address
wcga = 0704206 " S-2: ???
raef = 0700742 " S-2: resume after edges flag
rlpd = 0700723 " S-2: resume after light pen stop, disabled
beg = 0700547 " S-2: begin
spb = 0704401 " S-2: skip on push button flag
cpb = 0704404 " S-2: clear push button flag
lpb = 0704412 " S-2: load push buttons
wbl = 0704424 " S-2: write button lights
dprs = 0704752 " dataphone: read status
dpsf = 0704741 " dataphone: skip on flag
dpcf = 0704761 " dataphone: clear flag
dprc = 0704712 " dataphone: read character
crsf = 0706701 " CDR: skip if ready
crrb = 0706712 " CDR: read buffer
tools/a7out
+161 -117
View File
@@ -27,6 +27,8 @@ use constant MAXPOSINT => 0377777; # Biggest signed integer
use constant MAXADDR => 017777; # Largest memory address
use constant LINKMASK => 01000000; # Mask for LINK register
use constant EAESTEP => 077; # EAE step count mask
use constant EAEIMASK => 0777700; # EAE instruction mask
use constant SIGN => 0400000; # Sign bit
### Main program ###
@@ -35,12 +37,13 @@ while ( defined( $ARGV[0] ) && ( $ARGV[0] =~ m{^-} ) ) {
# -d: debug mode
if ( $ARGV[0] eq "-d" ) {
$debug = 1; shift(@ARGV);
$debug = 1;
shift(@ARGV);
}
# -b: set a breakpoint
if ( $ARGV[0] eq "-b" ) {
$singlestep = 1; shift(@ARGV);
shift(@ARGV);
$Breakpoint{ oct( shift(@ARGV) ) } = 1;
}
}
@@ -142,7 +145,7 @@ sub set_arguments {
my $c1 = substr( $str, $i, 1 ) || "";
my $c2 = substr( $str, $i + 1, 1 ) || "";
#printf("Saving %06o to %06o\n", (ord($c1) << 9 ) | ord($c2), $addr);
#printf("Saving %06o to %06o\n", (ord($c1) << 9 ) | ord($c2), $addr);
$Mem[ $addr++ ] = ( ord($c1) << 9 ) | ord($c2);
}
}
@@ -166,8 +169,7 @@ sub simulate {
oct("054") => \&sad,
oct("060") => \&jmp,
oct("064") => \&eae,
oct("070") => \&iot,
oct("074") => \&special,
oct("074") => \&opr,
);
# Loop indefinitely
@@ -183,18 +185,21 @@ sub simulate {
my $indaddr = ($indirect) ? $Mem[$addr] & MAXADDR : $addr;
# If this is a breakpoint, stop now and get a user command
$singlestep = 1 if ( defined( $Breakpoint{$PC} ) );
if ( defined( $Breakpoint{$PC} ) ) {
$singlestep = 1;
dprintf( "break at PC %06o\n", $PC );
}
get_user_command() if ($singlestep);
dprintf( "PC %06o: ", $PC );
#dprintf("PC %06o: instr %06o, op %03o, in %o, addr %06o indaddr %06o\n",
# $PC, $instruction, $opcode, $indirect, $addr, $indaddr );
#dprintf("PC %06o: instr %06o, op %03o, in %o, addr %06o indaddr %06o\n",
# $PC, $instruction, $opcode, $indirect, $addr, $indaddr );
# Simulate the instruction. Each subroutine updates the $PC
if ( defined( $Oplist{$opcode} ) ) {
$Oplist{$opcode}->( $instruction, $addr, $indaddr );
} else {
printf( STDERR "Unknown instruction 0%o at location 0%o\n",
printf( STDERR "Unknown instruction 0%06o at location 0%06o\n",
$instruction, $PC );
exit(1);
}
@@ -243,14 +248,18 @@ sub tad {
sub add {
my ( $instruction, $addr, $indaddr ) = @_;
dprintf( "add AC (value %06o) with addr %06o (%06o)\n",
$PC, $AC, $indaddr, $Mem[$indaddr] );
$LINK = 0;
$AC = $AC + $Mem[$indaddr];
if ( $AC & LINKMASK ) {
$AC++; # End-around carry
$LINK = LINKMASK;
$AC, $indaddr, $Mem[$indaddr] );
# This logic shamelessly borrowed from SimH
# https://github.com/simh/simh/blob/master/PDP18B/pdp18b_cpu.c
my $sum = $AC + $Mem[$indaddr];
if ( $sum > MAXINT ) { # end around carry
$sum = ( $sum + 1 ) & MAXINT;
}
$AC = $AC & MAXINT;
if ( ( ( ~$AC ^ $sum ) & ( $AC ^ $sum ) ) & SIGN ) { # overflow?
$LINK = LINKMASK; # set link
}
$AC = $sum;
$PC++;
}
@@ -290,7 +299,7 @@ sub dzm {
# Index and skip if zero
sub isz {
my ( $instruction, $addr, $indaddr ) = @_;
dprintf( "isz %06o\n", $Mem[$indaddr] );
dprintf( "isz %06o (value %06o)\n", $indaddr, $Mem[$indaddr] );
$Mem[$indaddr]++;
$Mem[$indaddr] &= MAXINT;
$PC += ( $Mem[$indaddr] == 0 ) ? 2 : 1;
@@ -313,79 +322,127 @@ sub jms {
$PC = $indaddr;
}
# Special instructions
sub special {
my $instruction = shift;
# OPR instructions
sub opr {
my ( $instruction, $addr, $indaddr ) = @_;
# Deal with each one in turn
# hlt
# hlt: halt simulation
if ( $instruction == 0740040 ) {
printf( STDERR "PC %06o: program halted\n", $PC );
dump_memory( 0, MAXADDR, 0 ) if ($debug);
exit(1);
}
if ( $instruction == 0741100 ) { # spa: skip on positive AC
dprintf( "spa AC %06o\n", $AC );
# Because we are dealing with 18 bits, compare the range
$PC += ( ( $AC >= 0 ) && ( $AC <= MAXPOSINT ) ) ? 2 : 1;
return;
}
if ( $instruction == 0741200 ) { # sna: skip on non-zero AC
dprintf( "sna AC %06o\n", $AC );
$PC += ( $AC != 0 ) ? 2 : 1;
return;
}
if ( $instruction == 0740200 ) { # sza: skip on zero AC
dprintf( "sza AC %06o\n", $AC );
$PC += ( $AC == 0 ) ? 2 : 1;
return;
}
if ( $instruction == 0741400 ) { # szl: Skip when $LINK is zero
dprintf( "szl LINK %0o\n", $LINK );
$PC += ( $LINK == 0 ) ? 2 : 1;
return;
}
if ( $instruction == 0740400 ) { # snl: Skip when $LINK not zero
dprintf( "snl LINK %0o\n", $LINK );
$PC += ( $LINK != 0 ) ? 2 : 1;
return;
}
if ( $instruction == 0741000 ) { # ska: skip always
dprintf("skp\n");
$PC += 2;
return;
}
# ral: rotate left or rcr: clear link then rotate left
if ( ( $instruction == 0740010 ) || ( $instruction == 0744010 ) ) {
$LINK = 0 if ( $instruction == 0744010 );
$AC = $AC << 1 + ($LINK) ? 1 : 0;
$LINK = $AC & LINKMASK;
$AC = $AC & MAXINT;
$PC++;
return;
}
# rar: rotate right or rcr: clear link then rotate right
if ( ( $instruction == 0740020 ) || ( $instruction == 0744020 ) ) {
$LINK = 0 if ( $instruction == 0744020 );
my $newlink = ( $AC & 1 ) ? LINKMASK : 0;
$AC = ( $LINK | $AC ) >> 1;
$LINK = $newlink;
$PC++;
return;
}
# law: load word into AC
if ( ( $instruction >= 0760000 ) && ( $instruction <= MAXINT ) ) {
my $indirect = ( $instruction >> 13 ) & 1;
if ($indirect) {
dprintf( "law %06o into AC\n", $instruction );
$AC = $instruction;
$PC++;
return;
}
printf( STDERR "PC %06o: unknown instruction %06o\n", $PC, $instruction );
exit(1);
# List of skip opcode names for the next section
my @skipop = (
'', 'sma', 'sza', 'sza sma',
'snl', 'snl sma', 'snl sza', 'snl sza sma',
'skp', 'spa', 'sna', 'sna spa',
'szl', 'szl spa', 'szl sna', 'szl sna spa'
);
# This logic shamelessly borrowed from SimH
# https://github.com/simh/simh/blob/master/PDP18B/pdp18b_cpu.c
my $skip = 0;
my $i = ( $instruction >> 6 ) & 017; # decode IR<8:11>
dprintf( "L.AC %d.%06o %s", ($LINK) ? 1 : 0, $AC, $skipop[$i] );
$skip = 1 if ( ( $i == 1 ) && ( $AC & SIGN ) != 0 ); # sma
$skip = 1 if ( ( $i == 2 ) && ( $AC & MAXINT ) == 0 ); # sza
$skip = 1 if ( ( $i == 3 )
&& ( ( ( $AC & MAXINT ) == 0 ) || ( ( $AC & SIGN ) != 0 ) ) )
; # sza | sma
$skip = 1 if ( ( $i == 4 ) && ($LINK) ); # snl
$skip = 1 if ( ( $i == 5 ) && ( $LINK || ( $AC >= SIGN ) ) ); # snl | sma
$skip = 1 if ( ( $i == 6 ) && ( $LINK || ( $AC == 0 ) ) ); # snl | sza
$skip = 1 if ( ( $i == 7 )
&& ( $LINK || ( $AC >= SIGN ) || ( $AC == 0 ) ) ); # snl | sza | sma
$skip = 1 if ( $i == 010 ); # skp
$skip = 1 if ( ( $i == 011 ) && ( ( $AC & SIGN ) == 0 ) ); # spa
$skip = 1 if ( ( $i == 012 ) && ( ( $AC & MAXINT ) != 0 ) ); # sna
$skip = 1 if ( ( $i == 013 )
&& ( ( $AC & MAXINT ) != 0 )
&& ( ( $AC & SIGN ) == 0 ) ); # sna & spa
$skip = 1 if ( ( $i == 014 ) && ( $LINK == 0 ) ); # szl
$skip = 1
if ( ( $i == 015 ) && ( $LINK == 0 ) && ( $AC < SIGN ) ); # szl & spa
$skip = 1
if ( ( $i == 016 ) && ( $LINK == 0 ) && ( $AC != 0 ) ); # szl & sna
$skip = 1 if ( ( $i == 017 )
&& ( $LINK == 0 )
&& ( $AC != 0 )
&& ( $AC != 0 ) ); # szl & sna & spa
# Clear operations
if ( $instruction & 010000 ) { # cla
dprintf(" cla"); $AC = 0;
}
if ( $instruction & 004000 ) { # cli
dprintf(" cli"); $LINK = 0;
}
if ( $instruction & 000002 ) { # cmi
dprintf(" cmi");
$LINK = ($LINK) ? 0 : LINKMASK;
}
if ( $instruction & 000001 ) { # cma
dprintf(" cma");
$AC = ( $AC ^ MAXINT ) & MAXINT;
}
# Rotate instructions
$i = $instruction & 02030;
# Single rotate right
if ( $i == 020 ) {
dprintf(" rar");
my $newlink = ( $AC & 1 ) ? LINKMASK : 0;
$AC = ( $LINK | $AC ) >> 1;
$LINK = $newlink;
}
# Double rotate right
if ( $i == 02020 ) {
dprintf(" rtr");
my $msb = ( $AC & 1 ) << 17;
my $newlink = ( $AC & 2 ) ? LINKMASK : 0;
$AC = ( ( $LINK | $AC ) >> 2 ) | $msb;
$LINK = $newlink;
}
# Single rotate left
if ( $i == 010 ) {
dprintf(" ral");
my $newlink = ( $AC & SIGN ) ? LINKMASK : 0;
my $lsb = $LINK ? 1 : 0;
$AC = ( ( $AC << 1 ) | $lsb ) & MAXINT;
$LINK = $newlink;
}
# Double rotate left
if ( $i == 02010 ) {
dprintf(" rtl");
my $newlink = ( $AC & 0200000 ) ? LINKMASK : 0;
my $lsb = ( $AC & SIGN ) ? 1 : 0;
my $twolsb = $LINK ? 2 : 0;
$AC = ( ( $AC << 2 ) | $twolsb | $lsb ) & MAXINT;
$LINK = $newlink;
}
# Impossible left and right rotates: 02030 or 00030. Do nothing!
# Note: We didn't do the oas instruction above.
$PC += 1 + $skip;
dprintf("\n");
return;
}
# cal: used for system calls
@@ -414,25 +471,23 @@ sub cal {
sub eae {
my ( $instruction, $addr, $indaddr ) = @_;
my $step = $instruction & EAESTEP;
$instruction &= EAEIMASK;
if ( $instruction == 0660500 ) { # lrss: long right shift, signed
# We ignore the MQ as it's not
# used by any user-mode programs
dprintf( "lrss %06o AC step %d\n", $AC, $step );
# Save the AC's sign into LINK
$LINK = ( $AC << 1 ) & LINKMASK;
# XXX: Do we need to preserve the AC sign?
$AC = $AC >> $step;
my $newlink = ( $AC << 1 ) & LINKMASK;
$AC = ( ( $LINK | $AC ) >> $step ) & MAXINT;
$LINK = $newlink;
$PC++;
return;
}
if ( $instruction == 0660711 ) { # alss: long left shift, signed
if ( $instruction == 0660700 ) { # alss: long left shift, signed
# We don't fill the lsb with LINK yet
dprintf( "alss %06o AC step %d\n", $AC, $step );
# Save the AC's sign into LINK
$LINK = ( $AC << 1 ) & LINKMASK;
# XXX: Do we need to preserve the AC sign?
$AC = ( $AC << $step ) & MAXINT;
$PC++;
return;
@@ -472,6 +527,7 @@ sub sys_close {
# Open system call
sub sys_open {
# Open seems to have 2 arguments: PC+1 is a pointer to the filename.
# PC+2 seems to be 1 for write, 0 for read.
# Some programs seem to have a third argument always set to 0.
@@ -480,17 +536,21 @@ sub sys_open {
# Get the start address of the string
my $start = $Mem[ $PC + 1 ];
# Convert this to a sensible ASCII filename
my $filename = mem2arg($start);
# Choose to open read-only or write-only
my $readorwrite = ( $Mem[ $PC + 2 ] ) ? ">" : "<";
dprintf( "open: base %06o, %s file %s\n", $start, $readorwrite, $filename );
# Bump up the PC
$PC += 3;
# Convert this to a sensible ASCII filename
my $filename = mem2arg($start);
dprintf( "open: base %06o, file %s\n", $start, $filename );
# Open the file
if ( open( my $FH, "<", $filename ) ) {
if ( open( my $FH, $readorwrite, $filename ) ) {
# Find a place in the @FD array to store this filehandle. 99 is arbitrary
# Find a place in the @FD array to store this filehandle.
# 99 is arbitrary
foreach my $fd ( 0 .. 99 ) {
if ( !defined( $FD[$fd] ) ) {
$FD[$fd] = $FH;
@@ -537,22 +597,12 @@ sub sys_read {
$count = 0;
foreach my $addr ( $start .. $end ) {
# It's a terminal, so convert from ASCII
if ( -t $FH ) {
my $c1 = getc($FH);
last if ( !defined($c1) ); # No character, leave the loop
my $c2 = getc($FH) || ""; # No character, make it a NUL
$Mem[$addr] =
( ord($c1) << 9 ) | ord($c2); # Pack both into one word
$count++;
} else {
# otherwise (for now) read in one line and convert to octal
my $line = <$FH>;
last if ( !defined($line) ); # No line, leave the loop
chomp($line);
$Mem[$addr] = oct($line) & MAXINT;
$count++;
}
my $c1 = getc($FH);
last if ( !defined($c1) ); # No character, leave the loop
my $c2 = getc($FH) || ""; # No character, make it a NUL
$Mem[$addr] =
( ord($c1) << 9 ) | ord($c2); # Pack both into one word
$count++;
}
# No error
@@ -573,7 +623,7 @@ sub sys_write {
my $end = ( $start + $count - 1 ) & MAXADDR;
die("sys_write: bad start/end addresses $start $end\n")
if ( $end < $start );
dprintf( "write: %d words from %o to fd %d\n", $count, $start, $fd );
dprintf( "write: %d words from %06o to fd %d\n", $count, $start, $fd );
# Bump up the PC
$PC += 3;
@@ -589,13 +639,7 @@ sub sys_write {
my $FH = $FD[$fd];
foreach my $addr ( $start .. $end ) {
# It's a terminal, so convert to ASCII
# otherwise (for now) print in octal
if ( -t $FH ) {
print( $FH word2ascii( $Mem[$addr] ) );
} else {
printf( $FH "%06o\n", $Mem[$addr] );
}
print( $FH word2ascii( $Mem[$addr] ) );
}
# No error
tools/as7
+64 -57
View File
@@ -4,7 +4,7 @@
# and convert them into PDP-7 machine code
#
# (c) 2016 Warren Toomey, GPL3
# Tweaked by Phil Budne (expression parsing, "list" format)
# Tweaked by Phil Budne (line, expression parsing, "list" format)
#
use strict;
use warnings;
@@ -25,7 +25,6 @@ my $origline; # The original current input line of code
my $line; # line being parsed
my $stage = 1; # Pass one or pass two
my $errors = 0; # set to non-zero on error
my %Undef; # undefined symbols: only complain once
my $line_error = ' ';
my $file; # current file name
my $lineno; # current line number
@@ -149,7 +148,7 @@ usage() if ( @ARGV < 1 );
rsb => 0700144, # select PTR in binary mode
psf => 0700201, # skip if PTP flag set
pcf => 0700202, # clear PTP clag
pcf => 0700202, # clear PTP flag
psa => 0700204, # punch PTP in alphanumeric mode
psb => 0700244, # punch PTP in binary mode
@@ -157,7 +156,7 @@ usage() if ( @ARGV < 1 );
krb => 0700312, # read KBD buffer
iors => 0700314, # input/output read status
tsf => 0700401, # if if TTY output flag set
tsf => 0700401, # skip if if TTY output flag set
tcf => 0700402, # clear TTY output flag
tls => 0700406, # load TTY output buffer and select
@@ -272,8 +271,9 @@ sub parse_file {
close($IN);
}
# process a label and set its value to the location counter (only called on pass 1)
# (if called on pass 2, should check if values are identical)
# process a label and set its value to the location counter
# only called on pass 1;
# if called on pass 2, should check if values are identical
sub process_label {
my $label = shift;
@@ -294,25 +294,21 @@ sub process_label {
}
# Blame Phil for this....
# parses global $line based on prefixes
# (nibbling of a bit at a time)
# parses global $line based on prefixes, nibbling of a bit at a time
# (: and ; can appear in char literals)
# handles multiple ';' separated words per line
sub parse_line {
$line_error = ' ';
while (1) {
$line_error = ' '; # clear listing error indicator
return if ($line eq '' || $line =~ m{^"}); # empty or comment: quit
# Lose any leading whitespace
$line =~ s{^\s*}{};
print "parse_line: '$line'\n" if ($debug);
return if ($line eq '');
if ($line =~ m{^"}) { # remainder of line is comment
return;
}
if ($line =~ s{^([a-z0-9\.]+):}{}) { # label
while ($line =~ s{^([a-z0-9\.]+):\s*}{}) { # labels
my $label = $1;
# First pass: parse the labels
@@ -321,44 +317,40 @@ sub parse_line {
process_label($1);
}
}
else {
my $lhs = undef;
if ( $line =~ s{^(\S+)\s*=}{}) { # assignment
$lhs = $1;
}
if ( $line =~ s{^(\S+)\s*=}{}) { # assignment
my $lhs = $1;
my $word = parse_expression();
if ($lhs) {
printf( "Setting variable %s to 0%o\n", $lhs, $word ) if ($debug);
$Var{$lhs} = $word;
printf("\t%06o %s\n", $word, $line_error) if ($stage == 2 && $format eq 'list');
}
else { # bare expression
# Get its value on pass two and save to memory
# Also save the input line that altered memory
if ( $stage == 2 ) {
my $location = $Var{'.'};
$Mem[$location] = $word;
$Mline[$location] = $origline;
$origline = '';
if ($format eq 'list') {
printf( "%06o: %06o %s\n", $location, $word, $line_error);
}
printf( "Setting variable %s to 0%o\n", $lhs, $word ) if ($debug);
$Var{$lhs} = $word;
printf("\t%06o %s\n", $word, $line_error) if ($stage == 2 && $format eq 'list');
}
else { # bare expression
# Get its value on pass two and save to memory
# Also save the input line that altered memory
my $word = parse_expression();
if ( $stage == 2 ) {
my $location = $Var{'.'};
$Mem[$location] = $word;
$Mline[$location] = $origline;
$origline = '';
if ($format eq 'list') {
printf( "%06o: %06o %s\n", $location, $word, $line_error);
}
# Move up to the next location in both passes
$Var{'.'}++;
} # expr
} # assignment or expression
}
# Move up to the next location in both passes
$Var{'.'}++;
} # expr
# eat trailing whitespace and ";", if any
$line =~ s{^\s*}{};
$line =~ s{^;}{};
$line =~ s{^\s*;?}{};
} # while
}
# Blame Phil for this bit too...
# Parse an expression off $line and return a PDP-7 word
# as a series of whitespace separated "syllables"
# and adds them together.
# ORed, added, or subtracted
sub parse_expression {
my $word = 0;
@@ -366,23 +358,22 @@ sub parse_expression {
while (1) {
my $syllable = 0;
my $sign = 1;
my $op = '|';
$line =~ s{^\s+}{};
print " '$line'\n" if ($debug);
if ($line eq '' || $line =~ m{^[";]}) { # EOL ; and " terminate expr
printf("\tparse_expression => %#o\n", $word) if ($debug);
return $word;
}
print " '$line'\n" if ($debug);
if ($line =~ s{^-}{}) {
# leading '-' negates upcomming syllable.
$sign = -$sign;
$op = '-';
}
else {
# ignore leading '+'
$line =~ s{^\+}{};
elsif ($line =~ s{^\+}{}) {
$op = '+';
}
if ($line =~ s{^<(.)}{}) { # <char
@@ -406,8 +397,7 @@ sub parse_expression {
printf("\tlbl: %s: %#o\n", $sym, $syllable) if ($debug);
}
elsif ($stage == 2) {
err('U', "$sym not defined") unless (defined $Undef{$sym});
$Undef{$sym} = 1; # only complain once
err('U', "$sym not defined")
} # pass 2
} # symbol
elsif ( $line =~ s{^(\d+)([fb])}{} ) { # relative label
@@ -421,14 +411,31 @@ sub parse_expression {
else {
$syllable = $value + 0;
}
$syllable &= 0777777;
}
else {
# From the BSD fortune file:
# Ken Thompson has an automobile which he helped design.
# Unlike most automobiles, it has neither speedometer,
# nor gas gauge, nor any of the numerous idiot lights
# which plague the modern driver. Rather, if the driver
# makes any mistake, a giant "?" lights up in the center
# of the dashboard. "The experienced driver",
# he says, "will usually know what's wrong.
err('?', "huh? '$line'");
$line = '';
$line = ''; # abort processing
return $word;
}
$syllable = ($syllable * $sign) & 0777777;
$word = ($word + $syllable) & 0777777;
if ($op eq '+') {
$word += $syllable;
}
elsif ($op eq '-') {
$word -= $syllable;
}
else {
$word |= $syllable;
}
$word &= 0777777;
printf("\tsyllable: %#o word: %#o\n", $syllable, $word) if ($debug);
}
}
tools/wktcp.s
+111
View File
@@ -0,0 +1,111 @@
" Warren's cp program: cp arg1 arg2
main:
" Load the pointer pointer in 017777 to see if we have any arguments
lac 017777 i
sad d12
jmp 1f " We have 12 words, so we have 2 arguments
jmp argserror " Otherwise, print an error and exit
1: lac 017777 " Move five words past the argument word count
tad d5 " so that AC points at the first argument
" Save the pointer to the file name
dac name
" Open the input file and get the fd into AC
sys open; name:0; 0;
spa
jmp badfile " Negative fd, exit with an error message
dac infd " Save the file descriptor
lac 017777 " Move nine words past the argument word count
tad d9 " so that AC points at the second argument
dac name
dac name2
" Open the ouput file and get the fd into AC
sys open; name2:0; 1;
spa
jmp badfile " Negative fd, exit with an error message
dac outfd " Save the file descriptor
fileloop:
" Read five words into the buffer from the input file
" Five was chosen arbitrarily
lac infd
sys read; buf; 5
spa " Skip if result was >= 0
jmp readerror " Result was -ve, so error result
sna " Skip if result was >0
jmp fileend " Result was zero, so nothing left to read
" Save the count of words read in
dac 1f
" Write five words from the buffer to the output file
lac outfd
sys write; buf; 1:0
spa " Skip if result was >= 0
jmp writeerror " Result was -ve, so error result
" and loop back for more words to read
jmp fileloop
fileend:
" Close the open file descriptors
lac infd
sys close
lac outfd
sys close
sys exit
" This code comes from the real cat.s
badfile:
lac name " Get the pointer to the filename
dac 1f " Store it in 1f below
lac d8 " Load fd 8 which is stderr
sys write; 1:0; 4 " Write the name, max 4 words
lac d8 " Then write " ?\n"
sys write; 1f; 2
sys exit " and exit
1: 040; 077012 " String literal: " ?\n"
readerror:
" Print an "err read" string on stderr and exit
lac d8
sys write; noreadstr; 5
sys exit
noreadstr:
<er>;<r 040;<re>;<ad>;012000
writeerror:
" Print an "err write" string on stderr and exit
lac d8
sys write; nowritestr; 6
sys exit
nowritestr:
<er>;<r 040;<wr>;<it>;<e 012
argserror:
" Print an "bad args" string on stderr and exit
lac d8
sys write; badargs; 5
sys exit
badargs:
<ba>;<d 040;<ar>;<gs>;012000
infd: 0 " fd of the input file
outfd: 0 " fd of the output file
d5: 5
d9: 9
d8: 8 " stderr seems to have fd 8
d12: 12
" Input buffer for read
buf: .=.+5