In part 1, I talked about how to get FIG-Forth for the IBM PC running on PCjs. FIG-Forth was a popular and very compact, public-domain version of the medium speed Forth systems programming language and environment during the early 1980s. Then part 2 covers how to implement a very rudimentary disk-based editor as a precursor to an interactive full-screen editor.
It would be possible to implement a full-screen editor entirely using the existing word set, if it provided definitions that could control the position of the cursor on the screen and the ability to clear the screen.
Unfortunately, it's not possible to do that either by sending display control codes via EMIT, nor via any other special commands. EMIT does support some control codes, carriage return is 13 EMIT, backspace is 8 EMIT, cursor right is 9 EMIT and cursor down is 10 EMIT.
The rest just produce graphics characters.
Let's Do Some Machine Code!
It's inevitable I'd have to get onto some machine code at some point, and it turns out, pretty early on. That means I need some useful Forth and 8086 resources.
Firstly, there's an indispensable guide to the FIG-Forth core: The Systems Guide To FIG-Forth. In it, it says you can write machine code definitions using the ;CODE command. The idea is that you'd write something of the form:
: myMachineCodeDef ;CODE opCode0 C, opCode1 C, etc... ;
But that doesn't work as I imagined. Instead I found you need to do:
CREATE myMachineCodeDef opCode0 C, opCode1 C, etc... SMUDGE
Here, CREATE generates a CFA which points to the parameter field (by default), and because FIG-FORTH is an Indirect Threaded Forth, that's the machine code that gets executed. It's not quite the only way of doing it. The Jupiter Ace's method for executing machine code is to define a CODE word which jumps to machine code in the parameter field:
DEFINER CODE DOES> CALL ;CODE Noop 253 C, 233 C,
And Direct threaded Forths merely need to build a header without a CFA, because in these cases, the CFA is machine code itself.
Probably the compact resource for translating 8086 instructions is the 8086 datasheet itself. I obtained a copy from Carnegie Mellon University (which incidentally did some pioneering work in parallel processors in the 1970s).
The most critical action a machine code definition must perform is to jump to the next command. My solution is to use the NOOP word whose behaviour does nothing but jump to the next word to execute. We find the CFA of NOOP and take the contents to find the first executable 8086 instruction:
' NOOP CFA @
NOOP is just a single byte jump instruction followed by an 8-bit displacement. Because it's a relative address, we need to add the address following the jump to the 8-bit displacement and because a displacement is a signed 8-bit integer, we need to perform a sign extension to find the true address for NEXT. Finally, we'll need the jump instruction that can handle a 16-bit displacement, which is code 233. This gives us the following, new definitions:
: SXT DUP 127 > IF 256 - THEN ;
: NEXT [ ' NOOP @ DUP 1+ C@ SXT ( 2+ ) + ] LITERAL 233 C, HERE - , ;
A simple, obvious machine code definitions to add to FIG-FORTH is a pair of shift operations, because shifts are really common operations in systems languages, but in FIG-FORTH it seems strangely absent.
To write a workable machine code definition we also need to know what 8086 registers must be preserved in Forth and which can be overwritten. The Forth.ASM assembler code from the original FIGFORTH.ZIP file tells us that SI=IP, SP points to the parameter stack, BP points to the return stack; AX must be preserved and CS, DS, SS all point to the same segment for the Forth executable. However, DX, BX, CX, DI, ES can all be freely modified. So, the shift operations will involve popping the count from the top of the stack into CX (which can be trashed); then the value into BX (which can be trashed); shifting BX by CL and then pushing the result. This gives us:
CREATE << HEX 59 C, ( pop cx) 5B C, ( pop bx) 0D3 C, 0E3 C, ( shl bx,cl) 53 C, ( push bx)
NEXT DECIMAL SMUDGE
CREATE << HEX 59 C, ( pop cx) 5B C, ( pop bx) 0D3 C, 0EB C, ( shr bx,cl) 53 C, ( push bx)
NEXT DECIMAL SMUDGE
This means we can now e.g. multiply or divide by a power of 2 over 100 cycles (20µs) faster than before :-) .
BIOS Functions
Let's go back to cursor control now. The easiest way to do that is via the BIOS functions on an IBM PC. It turns out all the screen control functions are INT 10H BIOS functions, so by creating a generic INT10H BIOS definition, we can then simply supply all the parameters to it in a higher level Forth definition. This function will be simple and only involves popping the registers DX through to AX; then calling INT10H. It isn't documented, but INT10H can foul up BP.
CREATE INT10H ( AX BX CX DX --)
HEX
05A C, ( POP DX )
059 C, ( POP CX )
05B C, ( POP BX)
89 C, 0F8 C, ( MOV DI,AX mod=11 reg=111=di r/m=000=AX )
058 C, ( POP AX )
057 C, ( PUSH DI)
1E C, ( PUSH DS)
55 C, ( PUSH BP [101])
0CD C, 10 C, ( INT10H)
5D C, ( POP BP)
1F C, ( POP DS)
058 C, ( POP AX)
NEXT
DECIMAL SMUDGE
The only real complexity is that we need to load AX, but we also need to save AX too. It doesn't matter if DI gets trashed as Forth doesn't use it.
There are now quite a number of fun things we can add that use INT10H:
: AT ( R C ) SWAP 8 << + >R ( DX) 512 0 R> INT10H ; ( jupiter ace command for gotoxy)
; VMODE ( n -- ) 0 0 0 INT10H ; ( 0= 40 column 2= 80 column 4=cga)
: CLS 1536 15 0 1999 INT10H 0 0 AT ;
So, we can do 0 VMODE then 1536 HEX 1E00 0 1827 DECIMAL INT10H to put the screen into a 40 column mode with yellow text on a white background.
And with these commands, we can now write a full-screen editor!
