1
0
mirror of https://github.com/hsoft/collapseos.git synced 2024-12-24 14:28:06 +11:00

Copy z80a.fs to disk blocks

I don't remove z80a.fs yet because build process needs it, but that
will change shortly.
This commit is contained in:
Virgil Dupras 2020-04-19 20:36:13 -04:00
parent 98191d0b0d
commit 0892193cbe
31 changed files with 355 additions and 1 deletions

View File

@ -2,6 +2,7 @@ MASTER INDEX
3 Usage 30 Dictionary
70 Implementation notes 100 Block editor
200 Z80 assembler

13
blk/200 Normal file
View File

@ -0,0 +1,13 @@
Z80 Assembler
201 Guide 208 Instructions list
212 Loader 213 Variables & consts
215 Utils 216 OP1
218 OP1r 220 OP1qq
222 OP1rr 224 OP2
226 OP2n 228 OP2rn
230 OP2br 232 OProt
234 OP2r 236 OP2ss
238 OP3ddnn 240 OP3nn
242 Specials 246 Flow

15
blk/201 Normal file
View File

@ -0,0 +1,15 @@
The following words allow you to assemble z80 binaries. Being
Forth words, opcode assembly is a bit different than with a
typical assembler. For example, what would traditionally be
"ld a, b" would become "A B LDrr,".
H@ offset at which we consider our PC 0. Used to compute PC. To
have a proper PC, call "H@ ORG !" at the beginning of your
assembly process.
Labels are a convenient way of managing relative jump
calculations. Backward labels are easy. It is only a matter or
recording "HERE" and do subtractions. Forward labels record the
place where we should write the offset, and then when we get to
that point later on, the label records the offset there.

13
blk/202 Normal file
View File

@ -0,0 +1,13 @@
To avoid using dict memory in compilation targets, we
pre-declare label variables here, which means we have a limited
number of it. For now, 4 ought to be enough.
Flow
There are 2 label types: backward and forward. For each type,
there are two actions: set and write. Setting a label is
declaring where it is. It has to be performed at the label's
destination. Writing a label is writing its offset difference
to the binary result. It has to be done right after a relative
jump operation. Yes, labels are only for relative jumps.

14
blk/203 Normal file
View File

@ -0,0 +1,14 @@
For backward labels, set happens before write. For forward
labels, write happen before set. The write operation writes a
dummy placeholder, and then the set operation writes the offset
at that placeholder's address.
Variable actions are expected to be called with labels in
front of them. Example, "L2 FSET"
About that "1 -": z80 relative jumps record "e-2", that is,
the offset that *counts the 2 bytes of the jump itself*.
Because we set the label *after* the jump OP1 itself, that's 1
byte that is taken care of. We still need to adjust by another
byte before writing the offset.

16
blk/208 Normal file
View File

@ -0,0 +1,16 @@
Instructions list
r => A B C D E H L (HL)
ss/qq => BC DE HL AF/SP
cc => CNZ CZ CNC CC CPO CPE CP CM
LD [rr, rn, ddnn, (nn)HL, HL(nn), dd(nn), (nn)dd, rIXY, IXYr,
(DE)A, A(DE)]
ADD [r, n, HLss, IXss, IXIX, IYss, IYIY]
ADC [r, HLss]
CP [r]
SBC [r, HLss]
SUB [r, n]
PUSH [qq] POP [qq]
INC [r, ss] DEC [r, ss]
AND [r, n] OR [r, n] XOR [r, n] (cont.)

11
blk/209 Normal file
View File

@ -0,0 +1,11 @@
(cont.)
OUT [nA, (C)r] IN [An, r(C)]
SET [br] RES [br] BIT [br]
RL [r] RLC [r] SLA [r] RLA RLCA
RR [r] RRC [r] SRL [r] RRA RRCA
CALL [nn] DJNZ
JP [nn, (HL), (IX), (IY)]
JR [, Z, NZ, C, NC]
DI EI EXDEHL EXX HALT
NOP RET SCF

8
blk/212 Normal file
View File

@ -0,0 +1,8 @@
( 59 == z80a's memory )
H@ 0x59 RAM+ !
10 ALLOT
213 LOAD 215 LOAD 216 LOAD 217 LOAD 218 LOAD 220 LOAD 222 LOAD
223 LOAD 224 LOAD 226 LOAD 228 LOAD 230 LOAD 232 LOAD 234 LOAD
236 LOAD 238 LOAD 240 LOAD 242 LOAD 243 LOAD 244 LOAD 246 LOAD
247 LOAD

9
blk/213 Normal file
View File

@ -0,0 +1,9 @@
: Z80AMEM+ 0x59 RAM+ @ + ;
: ORG 0 Z80AMEM+ ;
: L1 2 Z80AMEM+ ; : L2 4 Z80AMEM+ ;
: L3 6 Z80AMEM+ ; : L4 8 Z80AMEM+ ;
: A 7 ; : B 0 ; : C 1 ; : D 2 ;
: E 3 ; : H 4 ; : L 5 ; : (HL) 6 ;
: BC 0 ; : DE 1 ; : HL 2 ; : AF 3 ; : SP AF ;
: CNZ 0 ; : CZ 1 ; : CNC 2 ; : CC 3 ;
: CPO 4 ; : CPE 5 ; : CP 6 ; : CM 7 ;

16
blk/215 Normal file
View File

@ -0,0 +1,16 @@
( Splits word into msb/lsb, lsb being on TOS )
: SPLITB
256 /MOD SWAP
;
: PC H@ ORG @ - ;
( A, spits an assembled byte, A,, spits an assembled word
Both increase PC. To debug, change C, to .X )
: A, C, ; : A,, SPLITB A, A, ;
: <<3 8 * ; : <<4 16 * ;
( As a general rule, IX and IY are equivalent to spitting an
extra 0xdd / 0xfd and then spit the equivalent of HL )
: IX 0xdd A, HL ; : IY 0xfd A, HL ;
: _ix+- 0xff AND 0xdd A, (HL) ;
: _iy+- 0xff AND 0xfd A, (HL) ;
: IX+ _ix+- ; : IX- 0 -^ _ix+- ;
: IY+ _iy+- ; : IY- 0 -^ _iy+- ;

10
blk/216 Normal file
View File

@ -0,0 +1,10 @@
: OP1 CREATE C, DOES> C@ A, ;
0xf3 OP1 DI, 0xfb OP1 EI,
0xeb OP1 EXDEHL, 0xd9 OP1 EXX,
0x76 OP1 HALT, 0xe9 OP1 JP(HL),
0x12 OP1 LD(DE)A, 0x1a OP1 LDA(DE),
0x00 OP1 NOP, 0xc9 OP1 RET,
0x17 OP1 RLA, 0x07 OP1 RLCA,
0x1f OP1 RRA, 0x0f OP1 RRCA,
0x37 OP1 SCF,

11
blk/217 Normal file
View File

@ -0,0 +1,11 @@
( Relative jumps are a bit special. They're supposed to take
an argument, but they don't take it so they can work with
the label system. Therefore, relative jumps are an OP1 but
when you use them, you're expected to write the offset
afterwards yourself. )
0x18 OP1 JR, 0x10 OP1 DJNZ,
0x38 OP1 JRC, 0x30 OP1 JRNC,
0x28 OP1 JRZ, 0x20 OP1 JRNZ,

11
blk/218 Normal file
View File

@ -0,0 +1,11 @@
( r -- )
: OP1r0
CREATE C,
DOES>
C@ ( r op )
OR A,
;
0x80 OP1r0 ADDr, 0x88 OP1r0 ADCr,
0xa0 OP1r0 ANDr, 0xb8 OP1r0 CPr,
0xb0 OP1r0 ORr, 0x90 OP1r0 SUBr,
0x98 OP1r0 SBCr, 0xa8 OP1r0 XORr,

15
blk/220 Normal file
View File

@ -0,0 +1,15 @@
( qq -- also works for ss )
: OP1qq
CREATE C,
DOES>
C@ ( qq op )
SWAP ( op qq )
<<4 ( op qq<<4 )
OR A,
;
0xc5 OP1qq PUSHqq, 0xc1 OP1qq POPqq,
0x03 OP1qq INCss, 0x0b OP1qq DECss,
0x09 OP1qq ADDHLss,
: ADDIXss, 0xdd A, ADDHLss, ; : ADDIXIX, HL ADDIXss, ;
: ADDIYss, 0xfd A, ADDHLss, ; : ADDIYIY, HL ADDIYss, ;

14
blk/222 Normal file
View File

@ -0,0 +1,14 @@
: _1rr
C@ ( rd rr op )
ROT ( rr op rd )
<<3 ( rr op rd<<3 )
OR OR A,
;
( rd rr )
: OP1rr
CREATE C,
DOES>
_1rr
;
0x40 OP1rr LDrr,

13
blk/223 Normal file
View File

@ -0,0 +1,13 @@
( ixy+- HL rd )
: LDIXYr,
( dd/fd has already been spit )
LDrr, ( ixy+- )
A,
;
( rd ixy+- HL )
: LDrIXY,
ROT ( ixy+- HL rd )
SWAP ( ixy+- rd HL )
LDIXYr,
;

7
blk/224 Normal file
View File

@ -0,0 +1,7 @@
: OP2 CREATE , DOES> @ 256 /MOD A, A, ;
0xedb1 OP2 CPIR,
0xed46 OP2 IM0,
0xed56 OP2 IM1,
0xed5e OP2 IM2,
0xed44 OP2 NEG,
0xed4d OP2 RETI,

13
blk/226 Normal file
View File

@ -0,0 +1,13 @@
( n -- )
: OP2n
CREATE C,
DOES>
C@ A, A,
;
0xd3 OP2n OUTnA,
0xdb OP2n INAn,
0xc6 OP2n ADDn,
0xe6 OP2n ANDn,
0xf6 OP2n ORn,
0xd6 OP2n SUBn,

11
blk/228 Normal file
View File

@ -0,0 +1,11 @@
( r n -- )
: OP2rn
CREATE C,
DOES>
C@ ( r n op )
ROT ( n op r )
<<3 ( n op r<<3 )
OR A, A,
;
0x06 OP2rn LDrn,

14
blk/230 Normal file
View File

@ -0,0 +1,14 @@
( b r -- )
: OP2br
CREATE C,
DOES>
0xcb A,
C@ ( b r op )
ROT ( r op b )
<<3 ( r op b<<3 )
OR OR A,
;
0xc0 OP2br SETbr,
0x80 OP2br RESbr,
0x40 OP2br BITbr,

16
blk/232 Normal file
View File

@ -0,0 +1,16 @@
( bitwise rotation ops have a similar sig )
( r -- )
: OProt
CREATE C,
DOES>
0xcb A,
C@ ( r op )
OR A,
;
0x10 OProt RLr,
0x00 OProt RLCr,
0x18 OProt RRr,
0x08 OProt RRCr,
0x20 OProt SLAr,
0x38 OProt SRLr,

14
blk/234 Normal file
View File

@ -0,0 +1,14 @@
( cell contains both bytes. MSB is spit as-is, LSB is ORed
with r )
( r -- )
: OP2r
CREATE ,
DOES>
@ SPLITB SWAP ( r lsb msb )
A, ( r lsb )
SWAP <<3 ( lsb r<<3 )
OR A,
;
0xed41 OP2r OUT(C)r,
0xed40 OP2r INr(C),

12
blk/236 Normal file
View File

@ -0,0 +1,12 @@
( ss -- )
: OP2ss
CREATE C,
DOES>
0xed A,
C@ SWAP ( op ss )
<<4 ( op ss<< 4 )
OR A,
;
0x4a OP2ss ADCHLss,
0x42 OP2ss SBCHLss,

11
blk/238 Normal file
View File

@ -0,0 +1,11 @@
( dd nn -- )
: OP3ddnn
CREATE C,
DOES>
C@ ( dd nn op )
ROT ( nn op dd )
<<4 ( nn op dd<<4 )
OR A,
A,,
;
0x01 OP3ddnn LDddnn,

11
blk/240 Normal file
View File

@ -0,0 +1,11 @@
( nn -- )
: OP3nn
CREATE C,
DOES>
C@ A,
A,,
;
0xcd OP3nn CALLnn,
0xc3 OP3nn JPnn,
0x22 OP3nn LD(nn)HL,
0x2a OP3nn LDHL(nn),

16
blk/242 Normal file
View File

@ -0,0 +1,16 @@
( dd nn -- )
: LDdd(nn),
0xed A,
SWAP <<4 0x4b OR A,
A,,
;
( nn dd -- )
: LD(nn)dd,
0xed A,
<<4 0x43 OR A,
A,,
;
: JP(IX), IX DROP JP(HL), ;
: JP(IY), IY DROP JP(HL), ;

14
blk/243 Normal file
View File

@ -0,0 +1,14 @@
( 26 == next )
: JPNEXT, 26 JPnn, ;
( 29 == chkPS )
: chkPS, 29 CALLnn, ;
: CODE
( same as CREATE, but with native word )
(entry)
( 23 == nativeWord )
23 C,
;
: ;CODE JPNEXT, ;

3
blk/244 Normal file
View File

@ -0,0 +1,3 @@
( Macros )
( clear carry + SBC )
: SUBHLss, A ORr, SBCHLss, ;

13
blk/246 Normal file
View File

@ -0,0 +1,13 @@
( Place BEGIN, where you want to jump back and AGAIN after
a relative jump operator. Just like BSET and BWR. )
: BEGIN, PC ;
: AGAIN, PC - 1- A, ;
: BSET PC SWAP ! ;
: BWR @ AGAIN, ;
( same as BSET, but we need to write a placeholder )
: FJR, PC 0 A, ;
: IFZ, JRNZ, FJR, ;
: IFNZ, JRZ, FJR, ;
: IFC, JRNC, FJR, ;
: IFNC, JRC, FJR, ;

9
blk/247 Normal file
View File

@ -0,0 +1,9 @@
: THEN,
DUP PC ( l l pc )
-^ 1- ( l off )
( warning: l is a PC offset, not a mem addr! )
SWAP ORG @ + ( off addr )
C!
;
: FWR BSET 0 A, ;
: FSET @ THEN, ;

View File

@ -210,7 +210,7 @@
0xdb OP2n INAn,
0xc6 OP2n ADDn,
0xe6 OP2n ANDn,
0xf6 OP2n Orn,
0xf6 OP2n ORn,
0xd6 OP2n SUBn,
( r n -- )