1136 lines
101 KiB
Plaintext
1136 lines
101 KiB
Plaintext
*-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:*
|
|
* *
|
|
* Note: Actual EXECing of statements does not occur until *
|
|
* after the computer returns to BASIC's RESTART routine ($D43C). *
|
|
* When input is requested, execution flows via the DOS hooks *
|
|
* into INPTINCP ($9E81). Here the exec flag is tested and *
|
|
* discovered to be set. As a result, the READEXEC routine *
|
|
* ($A682) is used to read data from the exec file. The state- *
|
|
* ments are interpreted as if they were encountered in the *
|
|
* immediate mode. *
|
|
* *
|
|
* Condition of major flags on entry: *
|
|
* - CONDNFLG ($AA51) = $00 = warmstart. *
|
|
* - ACTBSFLG ($AAB6) = $40 = Floating point basic in ROM. *
|
|
* - RUNTRUPT ($AAB7) = $00 = assume RUN cmd was not *
|
|
* interrupted. *
|
|
* - BASICCLD ($E000) = first byte of basic's coldstart *
|
|
* routine distinguishes type of *
|
|
* basic being used ($40 = A(ROM). *
|
|
* - OPUTCOND ($AA52) = $00 = evaluate start of input line.*
|
|
* - EXECFLAG ($AAB3) = non-zero value (actually the first *
|
|
* character of the exec filename). *
|
|
* = execing. *
|
|
* *
|
|
* NOTE THE FOLLOWING DISASSEMBLY IS INCOMPLETE. It is only *
|
|
* meant to provide a simplified example of the execution pattern *
|
|
* used by the EXEC command. *
|
|
* *
|
|
*-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:*
|
|
|
|
|
|
* NOTE: YOU ARE LEAVING THE COMFORTABLE WORLD
|
|
* OF DOS AND ENTERING THE MURKY REALM OF BASIC.
|
|
|
|
* BASIC's warmstart routine.
|
|
|
|
* GO THROUGH A LOT OF STEPS TO PRINT
|
|
* A CARRIAGE RETURN.
|
|
(D43C)
|
|
RESTART JSR CRDO
|
|
|
|
(DAFB)
|
|
CRDO LDA #$0D ;Positive ASCII for <cr>.
|
|
(DAFD) JSR OUTDO
|
|
|
|
(DB5C)
|
|
OUTDO ORA #$80 ;Convert to neg ASCII.
|
|
CMP #" " ;Is it a ctrl char.
|
|
BCC GODOPUT ;Branch if ctrl char.
|
|
ORA FLSHMSK ;;$40 for FLASH, $00 for INVERSE or NORMAL.
|
|
GODOPUT JSR COUT ;Go to the output handling routine.
|
|
(DB64)
|
|
|
|
(FDED)
|
|
COUT JMP (CSW)
|
|
------------
|
|
|
|
* DOS's output intercept routine.
|
|
(9EBD)
|
|
OPUTINCP JSR PREP4DOS
|
|
|
|
* Prepare for processing by DOS.
|
|
(9ED1)
|
|
PREP4DOS STA ASAVED ;Save (a), (y) & (x)
|
|
STX XSAVED ;registers.
|
|
STY YSAVED
|
|
TSX ;Adjust stack ptr &
|
|
INX ;save it so when we
|
|
INX ;later restore it &
|
|
(9EDD) STX STKSAVED ;then hit an "RTS"
|
|
;we will return to
|
|
;the ROUTINE THAT
|
|
;CALLED THE ROUTINE
|
|
;THAT CONTAINED THE
|
|
;"JSR SETUP".
|
|
;(In this case,
|
|
;set saved stk ptr
|
|
;to rtn to $DB67.)
|
|
|
|
* Handy entry point frequently
|
|
* used by assembly language
|
|
* programmers to disconnect
|
|
* DOS completely.
|
|
(9EE0)
|
|
UNCONDOS LDX #3
|
|
SETRUHKS LDA CSWTRUE,X ;Restore the I/O
|
|
STA CSW,X ;hooks 2 pt 2 the
|
|
DEX ;true I/O handlers.
|
|
BPL SETRUHKS ;4 bytes to move
|
|
(9EEA) RTS ;(0 to 3).
|
|
|
|
* Use current OPUTCOND value to index table containing
|
|
* address of output condition handlers. Do a "stack jump"
|
|
* to the appropriate condition handler entry point.
|
|
(9EC0) LDA OPUTCOND
|
|
ASL ;Times 2 cause 2 bytes/address.
|
|
TAX ;Set (x) to index tbl of entry pt addrs.
|
|
LDA OUTHNDTB+1,X ;Put adr of output handler on stack
|
|
PHA ;(hi byte first) and then do a "stack jump"
|
|
LDA OUTHNDTB,X ;to the appropriate entry point.
|
|
PHA
|
|
LDA ASAVED ;Get char to be printed.
|
|
(9ED0) RTS ;Execute the "stack jump".
|
|
|
|
.
|
|
.
|
|
STACK JUMP TO OPUTHDL0
|
|
.
|
|
.
|
|
* Output handler 0.
|
|
* (Evaluate start of line.)
|
|
(9EEB)
|
|
OPUTHDL0 LDX RUNTRUPT ;Was a RUN interrupted?
|
|
(9EEE) BEQ NONTRUPT ;Branch if not.
|
|
|
|
* File not being read.
|
|
(9EF3)
|
|
NONTRUPT LDX CONDNFLG ;Are we doing a warmstart ($00),
|
|
;coldstart ($80), using A(RAM) ($C0)
|
|
;or doing a READ ($01)?
|
|
(9EF6) BEQ SETIGNOR ;Branch if warmstarting.
|
|
|
|
* Doing a warmstart so set condition 2 as a
|
|
* default to signal that non-DOS commands
|
|
* should be ignored.
|
|
(9F00)
|
|
SETIGNOR LDX #2 ;SET CONDITION 2.
|
|
STX OPUTCOND
|
|
CMP DCTRLCHR ;Is the char = DOS's control character?
|
|
(9F08) BNE OPUTHDL2 ;No, it is a <cr> so branch.
|
|
|
|
* Output handler 2.
|
|
* (Ignore non-DOS commands.)
|
|
(9F23)
|
|
OPUTHDL2 CMP #$8D ;Is char a <rtn>?
|
|
BNE DSPLYALL ;Yes - fall thru.
|
|
SET2EVAL LDX #0 ;SET CONDITION 0 - evaluate start
|
|
STX OPUTCOND ;of line.
|
|
(9F2C) JMP DSPLYALL ;Go display char unconditionally.
|
|
------------
|
|
|
|
* Display the char.
|
|
(9FA4)
|
|
DSPLYALL JSR RESTOREG
|
|
|
|
* Restore (a), (y) & (x) registers.
|
|
(9FBA)
|
|
RESTOREG LDA ASAVED
|
|
LDY YSAVED
|
|
LDX XSAVED
|
|
SEC ;Why?????
|
|
(9FC4) RTS
|
|
|
|
(9FA7) JSR GODSPLY
|
|
|
|
* PRINT A <CR> THROUGH THE TRUE
|
|
* OUTPUT HANDLER.
|
|
(9FC5)
|
|
GODSPLY JMP (CSW)
|
|
------------
|
|
|
|
(FDF0)
|
|
COUT1 .
|
|
.
|
|
(See dis'mbly in APPLE II REFERENCE MANUAL.)
|
|
.
|
|
.
|
|
(RTS)
|
|
|
|
* Save registers.
|
|
(9FAA) STA ASAVED ;Save (a), (y) & (x) registers.
|
|
STY YSAVED
|
|
(9FB0) STX XSAVED
|
|
|
|
* Reset hooks & stack pointer.
|
|
(9FB3)
|
|
DOSEXIT JSR INITIOHK ;Reset DOS hooks.
|
|
|
|
* Initialize the I/O hooks so that DOS
|
|
* intercepts all input & output. For
|
|
* instance, if a routine encounters a
|
|
* "COUT JMP (CSW)", then execution will
|
|
* actually flow to DOS's output routine
|
|
* (OPUTINCP, $9EBD). Similarly, any
|
|
* rout'n that refers 2 "RDKEY JMP (KSW)"
|
|
* will actually jump to DOS's input
|
|
* routine (INPTINCP, $9E81).
|
|
*
|
|
* The true (ie. normal) hooks are saved,
|
|
* ex: KSW: KEYIN --> KSWTRUE: KEYIN.
|
|
* CSW: COUT1 --> CSWTRUE: COUT1.
|
|
* The intercepts are then set as follows:
|
|
* ADINPTCP: INPTINCP --> KSW: INPTINCP.
|
|
* ADOPUTCP: OPUTINCP --> CSW: OPUTINCP.
|
|
|
|
* Check if input hk needs 2 be reset.
|
|
(A851)
|
|
INITIOHK LDA KSW+1
|
|
CMP ADINPTCP+1
|
|
(A856) BEQ CKOUTHK ;Input hk already
|
|
;pts 2 DOS's input
|
|
;handler, so go chk
|
|
;the oputput hook.
|
|
|
|
* Save true input hook and then reset
|
|
* the input hook to point to DOS.
|
|
* (KSW: KEYIN --> KSWTRUE: KEYIN)
|
|
* (ADINPTCP: INPTINCP --> KSW: INPTINCP)
|
|
(A858) STA KSWTRUE+1
|
|
LDA KSW
|
|
STA KSWTRUE
|
|
LDA ADINPTCP
|
|
STA KSW
|
|
LDA ADINPTCP+1
|
|
(A868) STA KSW+1
|
|
|
|
* Check if output hk needs 2 be reset.
|
|
(A86A)
|
|
CKOUTHK LDA CSW+1
|
|
CMP ADOPUTCP+1
|
|
(A86F) BEQ SETHKRTN ;Output hk already
|
|
;points to DOS's
|
|
;output handler,
|
|
;so go exit.
|
|
|
|
* Save true output hook and then reset
|
|
* the output hook to point to DOS.
|
|
* (CSW: COUT1 --> CSWTRUE: COUT1)
|
|
* (ADOPUTCP: OPUTINCP --> CSW: OPUTINCP)
|
|
(A871) STA CSWTRUE+1
|
|
LDA CSW
|
|
STA CSWTRUE
|
|
LDA ADOPUTCP
|
|
STA CSW
|
|
LDA ADOPUTCP+1
|
|
STA CSW+1
|
|
SETHKRTN RTS
|
|
(A883)
|
|
|
|
* Reset stack pointer & save registers.
|
|
(9FB6) LDX STKSAVED ;Retrieve the saved stack pointer value
|
|
TXS ;& reset the stack to return to caller.
|
|
RESTOREG LDA ASAVED ;Restore (a), (y) & (x) registers.
|
|
LDY YSAVED
|
|
LDX XSAVED
|
|
SEC ;Return to routine that called routine
|
|
(9FC4) RTS ;that contained "JSR PREP4DOS" instruc.
|
|
|
|
* Convert char back to positive ASCII
|
|
* so we can keep Applesoft happy.
|
|
(DB67) AND #$7F ;Convert char.
|
|
PHA ;Save it on the stack.
|
|
LDA SPEEDFLG ;Delay in accordance with speed setting.
|
|
(DB6C) JSR WAIT
|
|
|
|
* Monitor ROM's main delay routine.
|
|
* Delay z number of cycles based on
|
|
* the formula:
|
|
* z = ((5 * a^2) + (27 * a) + 26) / 2
|
|
* where a = value in accumulator on entry.
|
|
(FCA8)
|
|
WAIT SEC ;Prepare for subtraction.
|
|
WAIT2 PHA ;Save (a) on the stack.
|
|
WAIT3 SBC #1 ;Keep on reducing (a)
|
|
BNE WAIT3 ;until it equals zero.
|
|
PLA ;Get original val of (a) off stack.
|
|
SBC #1 ;Reduce original (a) down to 0 again.
|
|
BNE WAIT2
|
|
(FCB3) RTS
|
|
|
|
(DB6F) PLA ;Get saved positive ASCII char back from stack.
|
|
(DB70) RTS
|
|
|
|
(DB00) EOR #$FF ;No reason for this???
|
|
(DB02) RTS
|
|
|
|
* PRINT THE APPLESOFT PROMPT through
|
|
* Basic, DOS's output handler (OPUTINCP)
|
|
* and the monitor. THEN, INTERCEPT INPUT
|
|
* through DOS's input handler (INPTINCP).
|
|
(D43F) LDX #$DD ;RH brackett for Applesoft prompt.
|
|
(D441) JSR INLINPL2
|
|
|
|
(D52E)
|
|
INLINPL2 STX PROMPT
|
|
(D530) JSR GETLN
|
|
|
|
* Get a line of input.
|
|
(FD6A)
|
|
GETLN LDA PROMPT ;Print prompt.
|
|
(FD6C) JSR COUT
|
|
|
|
(FDED)
|
|
COUT JMP (CSW) ;Output hook pts to DOS's output handler.
|
|
------------
|
|
|
|
* DOS's output intercept routine.
|
|
(9EBD)
|
|
OPUTINCP JSR PREP4DOS
|
|
|
|
(9ED1)
|
|
PREP4DOS STA ASAVED ;Save (a), (y) & (x)
|
|
STX XSAVED ;registers.
|
|
STY YSAVED
|
|
TSX ;Adjust stk ptr and
|
|
INX ;save it so that
|
|
INX ;when we later
|
|
(9EDD) STX STKSAVED ;restore it and hit
|
|
;an "RTS", we can
|
|
;return to routine
|
|
;that called the
|
|
;routine that
|
|
;contained the
|
|
;"JSR PREP4DOS"
|
|
;instruction.
|
|
;(In this case,
|
|
;set saved stk ptr
|
|
;to rtn to $FD6F.)
|
|
|
|
* Restore the I/O hooks to point to the
|
|
* true I/O handlers, ex:
|
|
* KSWTRUE: KEYIN --> KSW: KEYIN.
|
|
* CSWTRUE: COUT1 --> CSW: COUT1.
|
|
(9EE0)
|
|
UNCONDOS LDX #3
|
|
SETRUHKS LDA CSWTRUE,X
|
|
STA CSW,X
|
|
DEX
|
|
BPL SETRUHKS ; 4 bytes to move
|
|
(9EEA) RTS ;(0 to 3).
|
|
|
|
* Use current OPUTCOND value to index table containing
|
|
* address of output condition handlers. Do a "stack jump"
|
|
* to the appropriate condition handler entry point.
|
|
(9EC0) LDA OPUTCOND
|
|
ASL ;Times 2 cause 2 bytes/address.
|
|
TAX ;Set (x) to index table of addresses.
|
|
LDA OUTHNDTB+1,X ;Put adr of output handler on stack
|
|
PHA ;(hi byte first) and then do a "stack jump"
|
|
LDA OUTHNDTB,X ;to the appropriate entry point.
|
|
PHA
|
|
LDA ASAVED ;Get char to be printed.
|
|
(9ED0) RTS ;Execute the "stack jump".
|
|
|
|
.
|
|
.
|
|
STACK JUMP TO OPUTHDL0
|
|
.
|
|
.
|
|
* Output handler 0.
|
|
* (Evaluate start of line.)
|
|
(9EEB)
|
|
OPUTHDL0 LDX RUNTRUPT ;Was a RUN interrupted?
|
|
(9EEE) BEQ NONTRUPT ;Branch if not.
|
|
|
|
(9EF3)
|
|
NONTRUPT LDX CONDNFLG ;Are we doing a warmstart ($00),
|
|
;coldstart ($80), using A(RAM) ($C0)
|
|
;or doing a read ($01)?
|
|
(9EF6) BEQ SETIGNOR ;Branch if warmstarting.
|
|
|
|
* Warmstarting, so set condition 2.
|
|
(9F00)
|
|
SETIGNOR LDX #2 ;SET CONDITION 2 as a default to signal
|
|
STX OPUTCOND ;that we should ignore non-DOS commands.
|
|
CMP DCTRLCHR ;Is char = DOS's ctrl char?
|
|
(9F08) BNE OPUTHDL2 ;No, it is a prompt so take branch.
|
|
|
|
* Output handler 2.
|
|
* (Ignore non-DOS commands.)
|
|
(9F23)
|
|
OPUTHDL2 CMP #$8D ;<rtn>?
|
|
(9F25) BNE DSPLYALL ;No, isn't a <cr> so take branch.
|
|
|
|
* Display the char.
|
|
(9FA4)
|
|
DSPLYALL JSR RESTOREG
|
|
|
|
* Restore (a), (y) & (x) registers.
|
|
(9FBA)
|
|
RESTOREG LDA ASAVED
|
|
LDY YSAVED
|
|
LDX XSAVED
|
|
SEC ;Why?????
|
|
(9FC4) RTS
|
|
|
|
(9FA7) JSR GODSPLY
|
|
|
|
(9FC5)
|
|
GODSPLY JMP (CSW)
|
|
------------
|
|
|
|
* PRINT APPLESOFT PROMPT through
|
|
* the true output handler.
|
|
(FDF0)
|
|
COUT1 .
|
|
.
|
|
- print char thru true output handler.
|
|
(See dis'mbly in APPLE II REFERENCE MANUAL.)
|
|
.
|
|
.
|
|
(RTS)
|
|
|
|
* Save registers & reset hooks.
|
|
(9FAA) STA ASAVED ;Save (a), (y) & (x) registers.
|
|
STY YSAVED
|
|
(9FB0) STX XSAVED
|
|
|
|
* Routine to exit DOS.
|
|
(9FB3)
|
|
DOSEXIT JSR INITIOHK
|
|
|
|
* Initialize the I/O hooks so that DOS
|
|
* intercepts all input & output.
|
|
(A851)
|
|
INITIOHK .
|
|
.
|
|
(See dis'mbly above.)
|
|
.
|
|
.
|
|
(RTS)
|
|
|
|
(9FB6) LDX STKSAVED ;Retrieve the saved stack pointer val
|
|
TXS ;& reset the stack to return to caller.
|
|
RESTOREG LDA ASAVED ;Restore (a), (y) & (x) registers.
|
|
LDY YSAVED
|
|
LDX XSAVED
|
|
SEC ;Return to the routine that called the
|
|
(9FC4) RTS ;routine that contained the "JSR PREP4DOS"
|
|
;instruction.
|
|
|
|
*******************************
|
|
* *
|
|
* GET A SINGLE BYTE OF INPUT.
|
|
* *
|
|
*******************************
|
|
(FD6F) LDX #1
|
|
BCKSPC TXA ;Force fall thru to next instruction.
|
|
BEQ GETLNZ
|
|
DEX ;Initialize (x) = 0 as index to input buf.
|
|
NXTCHAR JSR RDCHAR
|
|
(FD75)
|
|
|
|
* Routine to read an input byte.
|
|
(FD35)
|
|
RDCHAR JSR RDKEY
|
|
|
|
(FD0C)
|
|
RDKEY LDY CH ;Get horiz cursor
|
|
;pos'n 4 nxt char.
|
|
(FD0E) LDA (BASL),Y ;Pick up char in next
|
|
(FD10) PHA ;screen pos'n & save
|
|
;it on the stack.
|
|
(FD11) AND #$3F ;Convert char to
|
|
ORA #$40 ;flashing.
|
|
(FD15) STA (BASL),Y ;Put flashing char
|
|
;on scrn to serve
|
|
;as cursor.
|
|
(FD17) PLA ;Get char back that
|
|
;cursor is replacing.
|
|
;(Need it in case do
|
|
;bkspc or -> and
|
|
;want to reinstate
|
|
;orig char on scrn).
|
|
(FD18) JMP (KSW) ;Input hook still
|
|
------------ ;pointing to DOS.
|
|
|
|
* DOS intercepts input.
|
|
(9E81)
|
|
INPTINCP JSR PREP4DOS ;Save regs & stk ptr
|
|
|
|
* Pt hks at true
|
|
* I/O handlers.
|
|
* (Adjust & save
|
|
* stk ptr to
|
|
* later return
|
|
* to $FD38.)
|
|
(9ED1)
|
|
PREP4DOS .
|
|
.
|
|
(See dis'mbly
|
|
above.)
|
|
.
|
|
.
|
|
(RTS)
|
|
|
|
(9E84) LDA CONDNFLG ;Test condition.
|
|
(9E86) BEQ INPUTWRM ;Branch if warmstart.
|
|
|
|
* Using warmstart condition.
|
|
* At this point, both CONDNFLG
|
|
* & OPUTCOND = 0 for both
|
|
* cold- and warmstarts.
|
|
(9E9E)
|
|
INPUTWRM LDA EXECFLG ;Are we execing?
|
|
BEQ INPTNOXC ;No
|
|
(9EA3) JSR READEXEC ;Yes - go read an
|
|
;exec file byte.
|
|
|
|
* Exec's read routine
|
|
(A682)
|
|
READEXEC .
|
|
.
|
|
.
|
|
.
|
|
-------------------------------------------------------------------------------------------------------------------
|
|
l * EXEC's read data routine.
|
|
l (A682)
|
|
l READEXEC JSR PT2EXEC
|
|
l
|
|
l * Point the A3L/+1 pointer at the
|
|
l * buffer we're execing in.
|
|
l (A69D)
|
|
l PT2EXEC LDA EXECBUFF+1 ;Get addr of DOS buf using to exec.
|
|
l STA A3L+1 ;Put in in the A3L/+1 pointer.
|
|
l LDA EXECBUFF
|
|
l STA A3L
|
|
l (A6A7) RTS
|
|
l
|
|
l (A685) JSR BUFS2PRM
|
|
l
|
|
l * Copy addresses of the various DOS
|
|
l * buffers from the chain buffer to
|
|
l * the FM parameter list.
|
|
l (A74E)
|
|
l BUFS2PRM LDY #30 ;Get addr of FM work buf, T/S list
|
|
l ADRINPRM LDA (A3L),Y ;buf, data sector buf & next DOS
|
|
l STA WRKBUFFM-30,Y ;file name buf from the chain
|
|
l INY ;pointers buf & put then in the FM
|
|
l CPY #38 ;parameter list. (P.S. Address of
|
|
l BNE ADRINPRM ;next DOS filename buf is not used
|
|
l (A75A) RTS ;by DOS.)
|
|
l
|
|
l (A688) LDA #3 ;SET CONDITION 3 so process
|
|
l (A68A) BNE SETCOND ;data input from the disk.
|
|
l -----------
|
|
l
|
|
l (A62D)
|
|
l SETCOND STA OPUTCOND
|
|
l (A630) JSR RDTXTBYT ;Go read a text file byte
|
|
l
|
|
l (A68C)
|
|
l RDTXTBYT LDA #3 ;Set READ opcode.
|
|
l STA OPCODEFM
|
|
l LDA #1 ;Set one-byte subcode.
|
|
l STA SUBCODFM
|
|
l (A696) JSR FMDRIVER ;Call the FM driver to read a data byte.
|
|
l
|
|
l * Use the file manager driver
|
|
l * to do the READ function.
|
|
l (A6A8)
|
|
l FMDRIVER JSR FILEMGR ;Call the file manager to do the function.
|
|
l
|
|
l * File manager proper.
|
|
l (AB06)
|
|
l FILEMGR TSX ;Save stk ptr so can later rtn 2 caller.
|
|
l STX STKSAV
|
|
l (AB0A) JSR RSTRFMWA
|
|
l
|
|
l * Copy FM work buf (in DOS chain) to
|
|
l * FM work area (not in DOS chain).
|
|
l (AE6A)
|
|
l RSTRFMWA JSR SELWKBUF
|
|
l
|
|
l * Get adr of FM work
|
|
l * buf from FM parm
|
|
l * list & put it in
|
|
l * the A4L/+1 pointer.
|
|
l (AF08)
|
|
l SELWKBUF LDX #0
|
|
l (AF0A) BEQ PT2FMBUF
|
|
l
|
|
l (AF12)
|
|
l PT2FMBUF LDA WRKBUFFM,X
|
|
l STA A4L
|
|
l LDA WRKBUFFM+1,X
|
|
l STA A4L+1
|
|
l (AF1C) RTS
|
|
l
|
|
l * Do the copying.
|
|
l (AE6D) LDY #0 ;Zero out return code
|
|
l (AE6F) STY RTNCODFM ;in FM parm list to
|
|
l ;signal no errors as
|
|
l (AE72) ;default condition.
|
|
l STORFMWK LDA (A4L),Y ;Copy FM work buf
|
|
l STA FMWKAREA,Y ;to FM work area.
|
|
l INY
|
|
l CPY #45 ;45 bytes to copy
|
|
l BNE STORFMWK ;(0 to 44).
|
|
l CLC ;Why?????
|
|
l (AE7D) RTS
|
|
l
|
|
l (AB0D) LDA OPCODEFM ;Check if opcode is legal.
|
|
l CMP #13 ;(Must be less than 13.)
|
|
l BCS TOERROP ;Opcode too large so got range error.
|
|
l ASL ;Double val of opcode & put it in (x)
|
|
l TAX ;so it indexes tables of adrs.
|
|
l LDA FMFUNCTB+1,X ;Stick adr of appropriate function
|
|
l PHA ;handler on stack (hi byte first).
|
|
l LDA FMFUNCTB,X
|
|
l PHA
|
|
l (AB1E) RTS ;DO "STACK JUMP" TO FUNCTION ENTRY POINT.
|
|
l
|
|
l (AC58)
|
|
l FNREAD LDA SUBCODFM ;Check if subcode is legal.
|
|
l CMP #5 ;(Must be < = 5.)
|
|
l (AC5D) BCS TOERRSUB ;Error - illegal subcode.
|
|
l ;(Not applciable to exec command.)
|
|
l (AC5F) ASL ;Subcode * 2, cause 2 bytes/address.
|
|
l LDA RDSUBTBL+1,X ;Get address (minus 1) of subfunction
|
|
l PHA ;entry point & stick it on the stack
|
|
l LDA RDSUBTBL,X ;(hi byte first). Then do a "stack
|
|
l PHA ;jump" to execute the given READ sub-
|
|
l (AC69) RTS ;function. (Exec command ALWAYS uses
|
|
l ;the READ-ONE-BYTE subfunction.)
|
|
l
|
|
l (AC8A)
|
|
l READONE .
|
|
l .
|
|
l (See dis'mbly of the
|
|
l read-one-byte subfunction.)
|
|
l .
|
|
l .
|
|
l (RTS)
|
|
l ============
|
|
l
|
|
l TOERROP JMP RNGERROP ;Go handle range error.
|
|
l (AB1F) ------------ ;(See dis'mbly of errors.)
|
|
l
|
|
l TOERRSUB JMP RNGERRSB ;Go handle range error.
|
|
l (AC6A) ------------ ;(See dis'mbly of errors.)
|
|
l
|
|
l * Return here after doing the READ function.
|
|
l * (Cause after @ function is done, use stack
|
|
l * to get back to the original caller.) Note that
|
|
l * (c) = 0 if a data byte was just read (regardless
|
|
l * of whether that data byte was a $00 or not).
|
|
l (A6AB)
|
|
l AFTRFUNC BCC FMDRVRTN ;(c) = 0 = no errors.
|
|
l LDA RTNCODFM ;Get error code from FM parameter list.
|
|
l CMP #$5 ;End-of-data error?
|
|
l (A6B2) BEQ TOAPPTCH ;Yes - not handled like other errors.
|
|
l ;File ends at a full data sec and so we
|
|
l ;encountered a zeroed-out T/S link or a
|
|
l ;zeroed-out data pair (trk sec vals for
|
|
l ;next data sec listed in T/S list).
|
|
l (A6B4) JMP OTHRERR ;Only take if got an error other than
|
|
l ;an end-of-data error. (See dis'mbly
|
|
l (A6B7) ;of errors.)
|
|
l TOAPPTCH JMP APNDPTCH ;(See dis'mbly of errors.)
|
|
l ------------
|
|
l (A6BA) NOP
|
|
l BK2FMDRV JSR CKIFAPND ; <----- Note: APNDPTCH returns here.
|
|
l (A6BB)
|
|
l
|
|
l * Check if doing Append command.
|
|
l (BA69)
|
|
l CKIFAPND LDX CMDINDEX ;Get command index.
|
|
l CPX #$1C ;Are we APPENDing?
|
|
l BEQ RTNCKAPN ;Yes - leave flag on.
|
|
l LDX #0 ;No - turn off append flag.
|
|
l STX APPNDFLG
|
|
l RTNCKAPN RTS
|
|
l (BA75)
|
|
l
|
|
l (A6BE) LDX #0 ;Zero out the one-data-byte buffer in FM parm list.
|
|
l STX ONEIOBUF ;(Also referred to as low byte of CURIOBUF.)
|
|
l FMDRVRTN RTS
|
|
l (A6C3)
|
|
l
|
|
l (A699) LDA ONEIOBUF ;Load (a) with byte just read.
|
|
l (A69C) RTS
|
|
l
|
|
l (A633) BNE NOTEND ;If byte read < > 0, then haven't hit
|
|
l ...........---------- ;end-of-file marker (eof) yet, so more
|
|
l . ;bytes to read.
|
|
l . (A635) JSR CLOSEONE ;Ran out of data, so go close file.
|
|
l . ;(See routine given in formatted
|
|
l . ;dis'mbly of CMDCLOSE.)
|
|
l . (A638) LDA #3 ;Using condition 3? (That is, handling
|
|
l . CMP OPUTCOND ;an INPUT statement?)
|
|
l . (A63D) BEQ DONEPOSN ;Yes - just go to an "RTS".
|
|
l . .....------------
|
|
l . .
|
|
l . .
|
|
l . ---->>> Return to INPTNOXC to GET INPUT FROM THE KEYBOARD after encountering out-of-data error >>>------.
|
|
l . .
|
|
l . .
|
|
l . .
|
|
l . (A60D) .
|
|
l . DONEPOSN RTS
|
|
l . ===
|
|
l . (A644) (9EA6)
|
|
l ..NOTEND CMP #$E0 ;Lowercase? INPTNOXC LDA #3 ;SET CONDITION 3 to
|
|
l BCC SAVIT ;Branch if using uppercase. (9EA8) STA OPUTCOND ;signal that we
|
|
l (A648) AND #$7F ;Convert lower to upper in order to ;want to process
|
|
l (A64A) ;fool the CAPTST routine in monitor ROM. ;input information.
|
|
l SAVIT STA ASAVED ;Save char read. (9EAB) JSR RESTOREG
|
|
l LDX XSAVED ;Get index to input buffer.
|
|
l BEQ TOEXIT ;Branch if first char. * Restore regs.
|
|
l DEX ;Turn hi bit on in previous char (9FBA)
|
|
l LDA BUF200,X ;stored in BUF200 to convert to RESTOREG LDA ASAVED
|
|
l ORA #$80 ;lowercase if necessary. LDY YSAVED
|
|
l STA BUF200,X LDX XSAVED
|
|
l TOEXIT JMP DOSEXIT ;Go to DOS's exit routine. SEC
|
|
l (A65B) ----------- (9FC4) RTS
|
|
l
|
|
l * Routine to exit DOS. (9EAE) JSR TOTRUIN
|
|
l (9FB3)
|
|
l DOSEXIT JSR INITIOHK * Go to the true
|
|
l * input handler.
|
|
l * Initialize the I/O hooks (9EBA)
|
|
l * so that DOS intercepts TOTRUIN JMP (KSW)
|
|
l * all input & output.
|
|
l (A851) * Increment the
|
|
l INITIOHK . * random # locs
|
|
l . * & GET CODE OF
|
|
l (See dis'mbly above.) * THE KEY PRESSED.
|
|
l . (FD1B)
|
|
l . KEYIN INC RNDL
|
|
l (RTS) BNE KEYIN2
|
|
l INC RNDH
|
|
l (9FB6) LDX STKSAVED ;Restore the stack pointer. KEYIN2 BIT KBD
|
|
l TXS BPL KEYIN
|
|
l RESTOREG LDA ASAVED ;Restore registers. STA (BASL),Y
|
|
l LDY YSAVED LDA KBD
|
|
l LDX XSAVED BIT KBDSTRB
|
|
l SEC ;Why????? (FD2E) RTS
|
|
l (9FC4) RTS ;RETURN TO THE ROUTINE THAT
|
|
l ============ ;CALLED THE ROUTINE THAT (9EB1) STA ASAVED ;SAVE CHAR JUST READ.
|
|
l ;CONTAINED THE "JSR PREP4DOS" (9EB4) STX XSAVED ;SAVE INDEX TO INPUT
|
|
l ;INSTRUCTION (ie. so return to $FD38). ;BUFFER.
|
|
l (9EB7) JMP DOSEXIT
|
|
l ------------
|
|
l
|
|
------> When no errors, returns to $FD38 by resetting the stack ----->. * Routine to exit DOS.
|
|
. (9FB3)
|
|
. DOSEXIT JSR INITIOHK
|
|
.
|
|
. * Initialize I/O hks
|
|
. * so DOS intercepts
|
|
. * all input & output.
|
|
. (A851)
|
|
. INITIOHK .
|
|
. .
|
|
. (See dis'mbly above.)
|
|
. .
|
|
. .
|
|
. (RTS)
|
|
.
|
|
. (9FB6) LDX STKSAVED ;Restore stk pointer.
|
|
. TXS
|
|
. RESTOREG LDA ASAVED ;Restore registers.
|
|
. LDY YSAVED
|
|
. LDX XSAVED
|
|
. SEC ;Why?????
|
|
. (9FC4) RTS ;RETURN TO THE ROUTINE
|
|
. ============ ;THAT CALLED THE
|
|
. ;ROUTINE THAT
|
|
. ;CONTAINED THE
|
|
. ;"JSR PREP4DOS"
|
|
. ;INSTRUCTION. (In this
|
|
. ;case, goes to $FD38.)
|
|
.
|
|
(FD38) CMP #$9B ;Was the escape key pressed?
|
|
BEQ ESC ;Yes - go handle escape.
|
|
(FD3C) RTS
|
|
|
|
(FD78) CMP #$95 ;Was char a ctrl-U (right arrow)?
|
|
BNE CAPTST ;No.
|
|
(FD7C) LDA (BASL),Y ;Yes - prepare to put the original image
|
|
; of char in the next screen pos'n
|
|
(FD7E) ; back on the screen.
|
|
CAPTST CMP #$E0 ;Was char lower case?
|
|
BCC ADDINP ;No - go put new char in the input buffer.
|
|
AND #$DF ;Convert lower case to upper case.
|
|
ADDINP STA BUFF200,X ;Put char in the input buffer.
|
|
CMP #$8D ;Was char input a <cr>?
|
|
(FD89) BNE NOTCR ;Branch if char wasn't a <cr>.
|
|
|
|
* A <cr> denoting the end of the input
|
|
* string was read from the exec file.
|
|
(FD8B) JSR CLREOL
|
|
|
|
* Clear to the end of the line.
|
|
(FC9C)
|
|
CLREOL LDY CH ;(y) = next char's screen position.
|
|
CLEOLZ LDA #" " ;(a) = space to blank out line.
|
|
CLEOL2 STA (BASL),Y ;Put blanks on screen from the next
|
|
INY ;char position to the end of the screen
|
|
CPY WNDWDTH ;line (as determined by WNDWDTH).
|
|
BCC CLEOL2
|
|
(FCA7) RTS
|
|
|
|
(FD8E)
|
|
CROUT LDA #$8D ;Set (a) = carriage return.
|
|
(FD90) BNE COUT ;ALWAYS.
|
|
|
|
(FDED)
|
|
COUT JMP (CSW)
|
|
------------
|
|
|
|
* DOS's output intercept routine.
|
|
(9EBD)
|
|
OPUTINCP JSR PREP4DOS
|
|
|
|
* Prepare for processing by DOS.
|
|
* Save the registers & stack pointer.
|
|
* Restore the I/O hooks to point to the
|
|
* true I/O handlers, ex:
|
|
* KSWTRUE: KEYIN --> KSW: KEYIN.
|
|
* CSWTRUE: COUT1 --> CSW: COUT1.
|
|
(9ED1)
|
|
PREP4DOS STA ASAVED ;Save (a), (y) & (x) registers.
|
|
STX XSAVED
|
|
STY YSAVED
|
|
TSX ;Adjust stack ptr & save it so when we
|
|
INX ;later restore it and then hit an "RTS"
|
|
INX ;instruction, we will return to the
|
|
(9EDD) STX STKSAVED ;ROUTINE THAT CALLED THE ROUTINE THAT
|
|
;CONTAINED THE "JSR PREP4DOS" INSTRUC.
|
|
;(In this case, set saved stk pointer
|
|
;so can later return to $FD78.)
|
|
|
|
* Handy entry point frequently used by
|
|
* assembly language programmers to disconnect
|
|
* DOS completely.
|
|
(9EE0)
|
|
UNCONDOS LDX #3
|
|
SETRUHKS LDA CSWTRUE,X ;Restore the I/O
|
|
STA CSW,X ;hooks 2 pt 2 the
|
|
DEX ;true I/O handlers.
|
|
BPL SETRUHKS ;4 bytes to move
|
|
(9EEA) RTS ;(0 to 3).
|
|
|
|
* Use current OPUTCOND value to index table containing
|
|
* address of output condition handlers. Do a "stack jump"
|
|
* to the appropriate condition handler entry point.
|
|
(9EC0) LDA OPUTCOND
|
|
ASL ;Times 2 cause 2 bytes/address.
|
|
TAX ;Set (x) to index tbl of entry pt addrs.
|
|
LDA OUTHNDTB+1,X ;Put adr of output handler on stack
|
|
PHA ;(hi byte first) and then do a "stack jump"
|
|
LDA OUTHNDTB,X ;to the appropriate entry point.
|
|
PHA
|
|
LDA ASAVED ;Get char to be printed.
|
|
(9ED0) RTS ;Execute the "stack jump".
|
|
|
|
.
|
|
.
|
|
STACK JUMP TO OPUTHDL3
|
|
.
|
|
.
|
|
* Output handler 3.
|
|
*(PROCESS THE INPUT INFORMATION.)
|
|
(9F2F)
|
|
OPUTHDL3 LDX #0 ;SET CONDITION 0 when input ends.
|
|
STX OPUTCOND
|
|
CMP #$8D ;Was char an input-terminating <cr>?
|
|
(9F36) BEQ ASUMIMED ;Yes.
|
|
|
|
(9F3F)
|
|
ASUMIMED PHA ;Save character on the stack.
|
|
(9F40) SEC ;(c) = 1, default condition to assume we
|
|
;are presently in the immediate mode.
|
|
(9F41) LDA EXECFLAG ;Check if we are EXECing.
|
|
(9F44) BNE TESTMODE ;Branch if we are EXECing.
|
|
|
|
(9F49)
|
|
TESTMODE PLA ;Retrieve char from the stack.
|
|
(9F4A) BCC TESTEXEC ;Branch if basic is running.
|
|
;(c) = 0 = either basic running.
|
|
;(c) = 1 = immediate mode or EXECing.
|
|
|
|
* EXECing or in immediate mode.
|
|
(9F4C) LDX XSAVED ;Retrieve index to the input buffer.
|
|
(9F4F) JMP PUTINBUF ;Go put char in input buf (CONDITION 1).
|
|
------------
|
|
|
|
* Put char in the input buffer and then
|
|
* go display char or else go parse the cmd.
|
|
(9F15)
|
|
PUTINBUF STA BUF200,X ;Put char in the input buffer.
|
|
INX ;Kick up index to the next buffer pos'n.
|
|
STX NDX2INBF
|
|
CMP #$8D ;Was char a carriage return?
|
|
BNE DSPLYCMD ;No.
|
|
(9F20) JMP PARSECMD ;Yes - got end of input, so now go
|
|
----------- ;and see if it is a DOS command.
|
|
|
|
* Input character was not a carriage return.
|
|
(FD3D)
|
|
NOTCR LDA INVFLG ;Save current inverse flag on stack.
|
|
PHA
|
|
LDA #$FF ;Set inverse flag to normal.
|
|
STA INVFLG
|
|
LDA BUF200,X ;Get char to be printed.
|
|
(FD47) JSR COUT
|
|
|
|
(FDED)
|
|
COUT JMP (CSW) ;Output hk pts to DOS's output handler.
|
|
------------
|
|
|
|
* DOS's output intercept routine.
|
|
(9EBD)
|
|
OPUTINCP JSR PREP4DOS
|
|
|
|
* Prepare for processing by DOS.
|
|
* Save the registers & stack pointer.
|
|
* Restore the I/O hooks to point to the
|
|
* true I/O handlers, ex:
|
|
* KSWTRUE: KEYIN --> KSW: KEYIN.
|
|
* CSWTRUE: COUT1 --> CSW: COUT1.
|
|
(9ED1)
|
|
PREP4DOS STA ASAVED ;Save (a), (y) & (x)
|
|
STX XSAVED ;registers.
|
|
STY YSAVED
|
|
TSX ;Adjust stack ptr &
|
|
INX ;save it so that
|
|
INX ;when we later
|
|
(9EDD) STX STKSAVED ;restore it and hit
|
|
;an "RTS", we can
|
|
;return to routine
|
|
;that called the
|
|
;routine that
|
|
;contained the
|
|
;"JSR PREP4DOS"
|
|
;instruction.
|
|
;(In this case,
|
|
;set saved stk ptr
|
|
;2 return 2 $FD4A.)
|
|
|
|
* Restore the I/O hooks to point to the
|
|
* true I/O handlers, ex:
|
|
* KSWTRUE: KEYIN --> KSW: KEYIN.
|
|
* CSWTRUE: COUT1 --> CSW: COUT1.
|
|
(9EE0)
|
|
UNCONDOS LDX #3
|
|
SETRUHKS LDA CSWTRUE,X ;Restore the I/O
|
|
STA CSW,X ;hooks 2 pt 2 the
|
|
DEX ;true I/O handlers.
|
|
BPL SETRUHKS ;4 bytes to move
|
|
(9EEA) RTS ;(0 to 3).
|
|
|
|
* Use current OPUTCOND value to index table containing
|
|
* address of output condition handlers. Do a "stack jump"
|
|
* to the appropriate condition handler entry point.
|
|
(9EC0) LDA OPUTCOND
|
|
ASL ;Times 2 cause 2 bytes/address.
|
|
TAX ;Set (x) to index tbl of entry pt addrs.
|
|
LDA OUTHNDTB+1,X ;Put adr of output handler on stack
|
|
PHA ;(hi byte first) and then do a "stack jump"
|
|
LDA OUTHNDTB,X ;to the appropriate entry point.
|
|
PHA
|
|
LDA ASAVED ;Get char to be printed.
|
|
(9ED0) RTS ;Execute the "stack jump".
|
|
|
|
.
|
|
.
|
|
STACK JUMP TO OPUTHDL3
|
|
.
|
|
.
|
|
* Output handler 3.
|
|
*(PROCESS THE INPUT INFORMATION.)
|
|
(9F2F)
|
|
OPUTHDL3 LDX #0 ;SET CONDITION 0 when input ends.
|
|
STX OPUTCOND
|
|
CMP #$8D ;Was char an input-terminating <cr>?
|
|
(9F36) BEQ ASUMIMED ;Yes.
|
|
|
|
* Char was not a carriage return.
|
|
(9F38)
|
|
TESTEXEC LDA EXECFLAG ;Are we EXECing?
|
|
BEQ DSPLYALL ;No.
|
|
(9F3D) BNE DSPLYINP ;Yes - flag contains first char of the
|
|
;name of the exec file.
|
|
|
|
* Display input conditionally.
|
|
(9F9D)
|
|
DSPLYINP LDA #%00100000 ;Set bit5 so see if using "MONI".
|
|
DSPLYCHR AND CIOCUMUL ;Test flag - see if should display.
|
|
(9FA2) BEQ DOSEXIT ;Take branch if don't want to display.
|
|
;(Specific bit was off. MON/NOMON cleared
|
|
;or set the specific bit.)
|
|
|
|
* Display the char.
|
|
(9FA4)
|
|
DSPLYALL JSR RESTOREG
|
|
|
|
* Restore (a), (y) & (x) registers.
|
|
(9FBA)
|
|
RESTOREG LDA ASAVED
|
|
LDY YSAVED
|
|
LDX XSAVED
|
|
SEC ;Why?????
|
|
(9FC4) RTS
|
|
|
|
(9FA7) JSR GODSPLY
|
|
|
|
(9FC5)
|
|
GODSPLY JMP (CSW)
|
|
------------
|
|
|
|
* PRINT INPUT CHAR THROUGH
|
|
* THE TRUE OUTPUT HANDLER.
|
|
(FDF0)
|
|
COUT1 .
|
|
.
|
|
(See dis'mbly in APPLE II REFERENCE MANUAL.)
|
|
.
|
|
.
|
|
(RTS)
|
|
|
|
* Save registers and reset hooks.
|
|
(9FAA) STA ASAVED ;Save (a), (y) & (x) registers.
|
|
STY YSAVED
|
|
(9FB0) STX XSAVED
|
|
|
|
* Routine to exit DOS.
|
|
(9FB3)
|
|
DOSEXIT JSR INITIOHK ;Reset DOS hooks.
|
|
|
|
* Initialize the I/O hooks so that DOS
|
|
* intercepts all input & output. For
|
|
* instance, if a routine encounters a
|
|
* "COUT JMP (CSW)", then execution will
|
|
* actually flow to DOS's output routine
|
|
* (OPUTINCP, $9EBD). Similarly, any
|
|
* rout'n that refers 2 "RDKEY JMP (KSW)"
|
|
* will actually jump to DOS's input
|
|
* routine (INPTINCP, $9E81).
|
|
*
|
|
* The true (ie. normal) hooks are saved,
|
|
* ex: KSW: KEYIN --> KSWTRUE: KEYIN.
|
|
* CSW: COUT1 --> CSWTRUE: COUT1.
|
|
* The intercepts are then set as follows:
|
|
* ADINPTCP: INPTINCP --> KSW: INPTINCP.
|
|
* ADOPUTCP: OPUTINCP --> CSW: OPUTINCP.
|
|
|
|
* Check if input hk needs 2 be reset.
|
|
(A851)
|
|
INITIOHK LDA KSW+1
|
|
CMP ADINPTCP+1
|
|
(A856) BEQ CKOUTHK ;Input hk already
|
|
;pts 2 DOS's input
|
|
;handler, so go chk
|
|
;the oputput hook.
|
|
|
|
* Save true input hook and then reset
|
|
* the input hook to point to DOS.
|
|
* (KSW: KEYIN --> KSWTRUE: KEYIN)
|
|
* (ADINPTCP: INPTINCP --> KSW: INPTINCP)
|
|
(A858) STA KSWTRUE+1
|
|
LDA KSW
|
|
STA KSWTRUE
|
|
LDA ADINPTCP
|
|
STA KSW
|
|
LDA ADINPTCP+1
|
|
(A868) STA KSW+1
|
|
|
|
* Check if output hk needs 2 be reset.
|
|
(A86A)
|
|
CKOUTHK LDA CSW+1
|
|
CMP ADOPUTCP+1
|
|
(A86F) BEQ SETHKRTN ;Output hk already
|
|
;points to DOS's
|
|
;output handler,
|
|
;so go exit.
|
|
|
|
* Save true output hook and then reset
|
|
* the output hook to point to DOS.
|
|
* (CSW: COUT1 --> CSWTRUE: COUT1)
|
|
* (ADOPUTCP: OPUTINCP --> CSW: OPUTINCP)
|
|
(A871) STA CSWTRUE+1
|
|
LDA CSW
|
|
STA CSWTRUE
|
|
LDA ADOPUTCP
|
|
STA CSW
|
|
LDA ADOPUTCP+1
|
|
STA CSW+1
|
|
SETHKRTN RTS
|
|
(A883)
|
|
|
|
* Reset stack pointer & save registers.
|
|
(9FB6) LDX STKSAVED ;Retrieve the saved stack pointer value
|
|
TXS ;& reset the stack to return to caller.
|
|
RESTOREG LDA ASAVED ;Restore (a), (y) & (x) registers.
|
|
LDY YSAVED
|
|
LDX XSAVED
|
|
SEC ;Return to routine that called routine
|
|
(9FC4) RTS ;that contained "JSR PREP4DOS" instruc.
|
|
|
|
(FD4A) PLA ;Restore the original contents of the
|
|
STA INVFLG ;inverse flag.
|
|
LDA BUF200,X ;(a) = char that was input.
|
|
CMP #$88 ;Was char a backspace?
|
|
BEQ BCKSPC ;Yes.
|
|
CMP #$98 ;Was char a ctrl-X (cancel char)?
|
|
BEQ CANCEL ;Yes.
|
|
CPX #$F8 ;Input 249 (0 to 248) chars yet?
|
|
BCC NOTCR1 ;No.
|
|
JSR BELL ;Yes - go ring the warning bell.
|
|
NOTCR1 INX ;Increase the input character counter.
|
|
(FD60) BNE NXTCHAR ;Character counter hasn't wrapped around
|
|
(FD62) . ;to zero yet, so go get next char.
|
|
CANCEL . ;Too many chrs were input, so go cancel
|
|
. ;the input line.
|
|
.
|
|
============
|
|
|
|
.
|
|
.
|
|
.
|
|
********************************************************
|
|
* *
|
|
* See disassembly titled "DOSCMDPARSING&PROCESSING". *
|
|
* *
|
|
*------------------------------------------------------*
|
|
* *
|
|
* - parses and executes the command. *
|
|
* - or adds an Applesoft program line. *
|
|
* - or generates a syntax-error message. *
|
|
* - On entry, an image of the stack pointer has *
|
|
* been adjusted and saved (to be later used to *
|
|
* cause execution to return to $D533 after the *
|
|
* command is executed). Eventually execution *
|
|
* flows back into the RESTART ($D43C) routine. *
|
|
* *
|
|
********************************************************
|
|
.
|
|
.
|
|
(9FCD) .
|
|
PARSECMD .
|
|
.
|
|
.
|