Top 10k strings from zx82.htm.orig in <root> / doc / technical / specifications /
Back to the directory listing
255 DEFB %00000000
146 DEFB $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF;
74 EXX ;
71 RET ; return.
68 DEFB %0<B>1</B>0000<B>1</B>0
65 DEFB %000<B>1</B>0000
56 ; -------------------
49 DEFB %0000<B>1</B>000
47 INC HL ;
46 ; ---------------------
46 ; ------------------
45 DEFB %00<B>1</B><B>1</B><B>1</B><B>1</B>00
44 ; -----------------
39 ; --------------------------
39 DEFB %0<B>1</B>000<B>1</B>00
38 DEFB $38 ;;end-calc
36 ; ------------------------------
34 ; --------------------
33 RST 20H ; NEXT-CHAR
32 ; -------------------------
30 ; ----------------------
29 DEFB %0<B>1</B>000000
28 ; -----------------------
28 ; 'Nonsense in BASIC'
25 ; ---------------------------------
25 ; --------------------------------
24 ; ------------------------
23 ; -----------------------------
22 DEC HL ;
21 ; --------------
21 RST 28H ;; FP-CALC
21 DEFB %00000<B>1</B>00
20 RST 18H ; GET-CHAR
20 RET ; return
19 ; ------------------------------------
19 DEFB %00<B>1</B>00000
18 ; -------------------------------
18 ; ---------------------------
18 DEFB $31 ;;duplicate
17 ; ----------------------------
17 EX DE,HL ;
16 ; -------------
15 ; ----------------
15 DEFB 'T'+$80
15 DEFB %0<B>1</B><B>1</B><B>1</B><B>1</B><B>1</B><B>1</B>0
14 ; ------------
14 DEFB $00 ; Class-00 - No further operands.
14 ; by routine.
13 RET ;
13 PUSH DE ;
13 DEFB 'E'+$80
13 DEFB %0<B>1</B><B>1</B><B>1</B><B>1</B><B>1</B>00
13 DEFB %00<B>1</B>0<B>1</B>000
13 DEFB $03 ;;subtract
12 ; -----------------------------------
12 ; -----------
12 POP HL ;
12 LD A,B ;
12 DEFB %00<B>1</B><B>1</B><B>1</B><B>1</B><B>1</B>0
12 DEFB %00<B>1</B><B>1</B><B>1</B>000
12 DEFB %00<B>1</B>00<B>1</B>00
12 CALL <A href="#L2530">L2530</a> ; routine SYNTAX-Z
12 ; 'Nonsense in BASIC'.
11 ; ----------------------------------
11 RET ; Return.
11 DEFB 'N'+$80
11 DEFB $00 ;;jump-true
10 PUSH HL ;
10 LD B,A ;
10 LD (HL),A ;
10 DEFB %000000<B>1</B>0
9 POP BC ;
9 INC HL ; address next
9 DEFB %0<B>1</B><B>1</B><B>1</B><B>1</B>000
9 DEFB %000<B>1</B><B>1</B>000
9 DEFB $04 ;;multiply
8 ;<font color=#339933></font>
8 RET ; and return.
8 DEFB 'R'+$80
8 DEFB %0<B>1</B>0<B>1</B>0<B>1</B>00
8 DEFB $0F ;;addition
8 CCF ; Complement Carry Flag
7 SCF ; set carry flag
7 RST 10H ; PRINT-A
7 RRA ;
7 POP DE ;
7 LD C,A ;
7 DEFB $02 ;;delete
7 DEFB $01 ;;exchange
7 CPL ;
7 CALL <A href="#L2D28">L2D28</a> ; routine STACK-A
6 ; ----------------------------------------
6 ; ---------------
6 ; ---------
6 LD E,(HL) ;
6 LD A,C ;
6 INC HL ; address next.
6 DEFB $34 ;;stk-data
6 CP $29 ; is it ')' ?
6 AND A ;
6 ; colour code.
5 XOR A ;
5 RLCA ;
5 PUSH BC ;
5 NOP ;
5 LD E,A ;
5 LD D,(HL) ;
5 LD A,D ;
5 LD A,($5C74) ; fetch command from T_ADDR
5 DEFB '$'+$80
5 DEFB %0<B>1</B><B>1</B><B>1</B>0000
5 DEFB %0000<B>1</B><B>1</B>00
5 DEFB $A2 ;;stk-half
5 DEFB $A1 ;;stk-one
5 CALL <A href="#L2FBA">L2FBA</a> ; routine FETCH-TWO
5 CALL <A href="#L1BEE">L1BEE</a> ; routine CHECK-END
5 CALL <A href="#L1601">L1601</a> ; routine CHAN-OPEN opens it.
5 BIT 1,(IY+$01) ; test FLAGS - is printer in use ?
5 AND A ; prepare for true subtraction.
5 ; command.
4 ;<font color=#339933> /----| </font>
4 ;<font color=#339933> /|</font>
4 ;****************************************
4 ; -------------------------------------------------------------------------
4 ; -----------------------------------------------------------------------
4 ; -----------------------------------------------
4 ; ----------------------------------------------
4 ; -------------------------------------------
4 ; -------------------------------------
4 SUB B ;
4 SBC HL,DE ;
4 RLA ;
4 RET Z ;
4 POP AF ;
4 LD D,A ;
4 LD C,(HL) ;
4 LD (HL),D ;
4 INC HL ; address next location.
4 INC (HL) ;
4 DEFW <A href="#L1793">L1793</a> ; Address: $1793; Address: CAT-ETC
4 DEFB 'S'+$80
4 DEFB 'P'+$80
4 DEFB 'D'+$80
4 DEFB ' '+$80
4 DEFB %0<B>1</B>00<B>1</B>0<B>1</B>0
4 DEFB %00<B>1</B><B>1</B>0000
4 DEFB %000<B>1</B><B>1</B><B>1</B>00
4 DEFB %0000<B>1</B><B>1</B><B>1</B>0
4 DEFB $F0 ;;Exponent: $80, Bytes: 4
4 DEFB $27 ;;int
4 DEFB $0D
4 DEFB $0A ; Error Report: Integer out of range
4 DEFB $05 ; Class-05 - Variable syntax checked
4 DEFB $02 ;;delete x, y.
4 DEFB $00 ;;(+00,+00,+00)
4 CP $2C ; is it ',' ?
4 CP $0D ; is it carriage return ?
4 CALL <A href="#L30C0">L30C0</a> ; routine PREP-M/D
4 CALL <A href="#L2D7F">L2D7F</a> ; routine INT-FETCH
4 BIT 6,(IY+$01) ; test FLAGS - Numeric or string result ?
4 ADD HL,DE ;
4 ; else default to zero.
4 ;
3 ; ---------------------------------------
3 ; ^ | v
3 ; 7 6 5 4 3 2 1 0
3 XOR A ; clear the accumulator.
3 SRL B ;
3 RRCA ; multiply
3 RR E ;
3 RR B ;
3 RL D ;
3 RET Z ; return if not.
3 RET Z ; return if checking syntax.
3 RET NZ ;
3 RES 6,(HL) ; signal string result.
3 NEG ; Negate
3 LD L,B ;
3 LD E,L ;
3 LD E,(HL) ; low byte to E
3 LD D,(HL) ; high byte to D
3 LD B,C ;
3 LD B,(HL) ;
3 LD A,L ;
3 LD A,(HL) ;
3 LD A,($5C74) ; fetch command from T_ADDR.
3 LD A,$FE ; select system channel 'S'
3 LD A,$80 ;
3 LD (HL),E ;
3 INC HL ; advance.
3 INC HL ; advance pointer.
3 INC HL ; advance past
3 INC HL ; advance address.
3 INC HL ; address low byte
3 INC HL ; address high byte
3 EXX ; switch back to main set
3 DEFW <A href="#L15C4">L15C4</a> ; REPORT-J
3 DEFB %0<B>1</B><B>1</B>000<B>1</B>0
3 DEFB %0<B>1</B>0<B>1</B>00<B>1</B>0
3 DEFB %0<B>1</B>00<B>1</B>000
3 DEFB %0<B>1</B>000<B>1</B><B>1</B>0
3 DEFB %00<B>1</B>000<B>1</B>0
3 DEFB %000<B>1</B>0<B>1</B>00
3 DEFB $F1 ;;Exponent: $81, Bytes: 4
3 DEFB $B0 ;;Exponent $00
3 DEFB $38 ;;end-calc x, y.
3 DEFB $37 ;;greater-0
3 DEFB $33 ;;jump
3 DEFB $0C ; Error Report: BREAK - CONT repeats
3 CP $3A ; is it ':' ?
3 CP $24 ; is it '$' ?
3 CALL <A href="#L2FDD">L2FDD</a> ; routine SHIFT-FP
3 CALL <A href="#L2DD5">L2DD5</a> ; routine FP-TO-A
3 CALL <A href="#L1C82">L1C82</a> ; routine EXPT-1NUM
3 CALL <A href="#L1601">L1601</a> ; routine CHAN-OPEN opens it
3 CALL <A href="#L1601">L1601</a> ; routine CHAN-OPEN
3 BIT 7,D ;
3 AND A ; test for zero - SAVE.
3 AND A ; prepare to subtract.
3 AND A ; clear carry
3 ADC A,$00 ;
3 ; syntax.
3 ; items.
3 ; expressions required.
3 ; expressions required with optional colour
3 ; 'Subscript out of range'
2 ;<font color=#339933> /x |</font>
2 ;<font color=#339933> /a |</font>
2 ;<font color=#339933> y</font>
2 ;<font color=#339933> a</font>
2 ;<font color=#339933> / |x</font>
2 ;<font color=#339933> / |o</font>
2 ;************************************************************************
2 ;***************************************************
2 ;**************************************************
2 ;*****************************************
2 ;***********************************
2 ;**********************************
2 ;*********************************
2 ;*******************************
2 ; the branch was here in runtime.
2 ; calculator stack.
2 ; It uses the series generator to produce Chebyshev polynomials.
2 ; ---------------------------------------------------------------------------
2 ; ------------------------------------------------------------------------
2 ; --------------------------------------------------------------------
2 ; ---------------------------------------------------------------
2 ; ---------------------------------------------
2 ; --------------------------------------------
2 ; ------------------------------------------
2 ; -----------------------------------------
2 ; -> The Entry Point.
2 ; +---------+-----------+------------+--------------+-------------+--
2 ; *********************************
2 ; --+----------+---+---------+-----------+---+------------+--+---+--
2 ; --+-------+--+------------+-------+-------+---------+-------+-+---+------+
2 ; also called from s-inkey$
2 ; True binary operations.
2 ; This section deals with the ZX Printer.
2 ; HL points to start of data.
2 ; <img src="new.gif">
2 XOR C ;
2 XOR B ; combine with column $00 - $1F
2 XOR A ; clear A
2 SUB C ;
2 SET 7,D ;
2 SCF ; set carry flag.
2 SCF ; prepare for true subtraction.
2 SBC HL,HL ;
2 SBC A,A ; result $00 or $FF
2 RST 28H ;; FP-CALC x, y, r.
2 RST 20H ; get NEXT-CHAR
2 RST 20H ; address NEXT-CHAR
2 RST 20H ; NEXT-CHAR advances character address.
2 RST 10H ; PRINT-A outputs it.
2 RRCA ; thirty-two.
2 RRCA ; rotate
2 RRCA ; by
2 RR L ;
2 RR H ;
2 RR D ;
2 RR C ;
2 RL E ;
2 RL D ; C<xxxxxxxx<C
2 RL C ;
2 RET Z ; return if so.
2 RET Z ; return if so
2 RET NZ ; return if not.
2 RET NC ; return with time-out.
2 RET C ;
2 RET ; return to STMT-RET.
2 RES 0,(IY+$02) ; update TV_FLAG - signal main screen in use
2 PUSH HL ; save start.
2 PUSH HL ; save pointer to start.
2 PUSH HL ; save on stack
2 PUSH HL ; save address
2 PUSH HL ; save HL register
2 PUSH HL ; registers.
2 PUSH HL ; and save.
2 PUSH HL ; and save on stack.
2 PUSH BC ; save line/column
2 PUSH AF ; save the flag.
2 PUSH AF ; save A and carry.
2 POP HL ; restore the pointer.
2 POP HL ; restore HL
2 POP DE ; restore STKEND.
2 POP BC ; restore the line/column.
2 POP BC ; restore length.
2 POP AF ; restore shifted exponent
2 POP AF ; restore control.
2 OR L ; for zero.
2 OR E ;
2 OR C ; for zero.
2 OR (HL) ;
2 NEG ; negate
2 LD L,E ; to HL
2 LD L,C ; number to HL.
2 LD L,C ;
2 LD HL,($5C59) ; fetch E_LINE to HL.
2 LD HL,($5C3D) ; fetch ERR_SP
2 LD HL,$5C3B ; address FLAGS
2 LD HL,$5C04 ; point to KSTATE-4
2 LD HL,$5C00 ; point to KSTATE-0
2 LD H,C ;
2 LD H,B ; transfer the
2 LD E,C ;
2 LD D,E ; transfer E to D
2 LD D,C ;
2 LD D,B ;
2 LD D,$00 ;
2 LD C,L ; to BC register pair.
2 LD C,L ; the BC register pair.
2 LD B,H ; transfer the result
2 LD B,A ; transfer count to B.
2 LD B,(HL) ; transfer to B.
2 LD B,(HL) ; high byte to B.
2 LD B,$00 ; prepare to add.
2 LD A,H ; test for zero
2 LD A,E ;
2 LD A,D ; fetch parameter
2 LD A,B ; test if
2 LD A,(HL) ; fetch to A
2 LD A,$30 ; prepare the character '0'
2 LD A,$20 ; prepare a space.
2 LD (HL),C ; insert low byte
2 LD (HL),C ;
2 LD (HL),B ; insert high byte
2 LD (HL),A ; store 2's complement.
2 LD (HL),A ; put back
2 LD (HL),A ; put a zero there.
2 LD (HL),A ; and blank.
2 JR Z,<A href="#L270D">L270D</a> ; forward if so to S-PUSH-PO
2 JR Z,<A href="#L1756">L1756</a> ; forward to OPEN-1 if so
2 JR Z,<A href="#L0D00">L0D00</a> ; forward to REPORT-D if so
2 JR Z,<A href="#L0310">L0310</a> ; forward to K-REPEAT if so
2 JR NZ,<A href="#L0A3A">L0A3A</a> ; to PO-BACK-3 if not and store new position.
2 JR NZ,<A href="#L046C">L046C</a> ; if no, error REPORT-B
2 JR NC,<A href="#L2244">L2244</a> ; back to REPORT-K if not
2 JR C,<A href="#L30BE">L30BE</a> ; to HL-END if overflow
2 JR <A href="#L3272">L3272</a> ; to NIL-BYTES
2 JR <A href="#L26C3">L26C3</a> ; forward to S-NUMERIC
2 JR <A href="#L1822">L1822</a> ; forward to LIST-5
2 JP Z,<A href="#L1C8A">L1C8A</a> ; jump to REPORT-C if so.
2 JP Z,<A href="#L1C8A">L1C8A</a> ; jump forward to REPORT-C if so.
2 JP <A href="#L2712">L2712</a> ; jump forward to S-CONT-2 ===>
2 INC HL ; input routine.
2 INC HL ; increment
2 INC HL ; advance source address.
2 INC HL ; advance
2 INC A ;
2 EXX ; switch to alt
2 EX DE,HL ; transfer to DE.
2 EX DE,HL ; swap the pointers.
2 EX DE,HL ; swap pointers
2 EI ; enable interrupts.
2 DI ; disable interrupts
2 DEFW <A href="#L09F4">L09F4</a> ; PRINT-OUT
2 DEFM "TA"
2 DEFM "LE"
2 DEFM "IN"
2 DEFB 'Y'+$80
2 DEFB 'W'+$80
2 DEFB 'M'+$80
2 DEFB 'K'+$80
2 DEFB 'B'+$80
2 DEFB '#'+$80
2 DEFB %<B>1</B>0<B>1</B>0000<B>1</B>
2 DEFB %<B>1</B>00<B>1</B><B>1</B>00<B>1</B>
2 DEFB %0<B>1</B>0<B>1</B><B>1</B>0<B>1</B>0
2 DEFB $EE ;;Exponent: $7E, Bytes: 4
2 DEFB $E9 ;;Exponent: $79, Bytes: 4
2 DEFB $E7 ;;Exponent: $77, Bytes: 4
2 DEFB $E1 ;;get-mem-1
2 DEFB $E0 ;;get-mem-0 ; push frequency
2 DEFB $C1 ;;st-mem-1
2 DEFB $A0 ;;stk-zero
2 DEFB $9E ;;Exponent: $6E, Bytes: 3
2 DEFB $8C ;;series-0C
2 DEFB $5C ;;Exponent: $6C, Bytes: 2
2 DEFB $58 ;;Exponent: $68, Bytes: 2
2 DEFB $3D ; Separator: '='
2 DEFB $36 ;;less-0
2 DEFB $34 ;;stk-data ; push constant
2 DEFB $32 ;;Exponent: $82, Bytes: 1
2 DEFB $31 ;;duplicate x, x.
2 DEFB $1B ;;negate
2 DEFB $17 ; Error Report: Invalid stream
2 DEFB $14 ;;Exponent: $64, Bytes: 1
2 DEFB $13 ;;Exponent: $63, Bytes: 1
2 DEFB $0E ; Error Report: Invalid file name
2 DEFB $0B ; Error Report: Nonsense in BASIC
2 DEFB $0A ; Class-0A - A string expression must follow.
2 DEFB $09 ; Error Report: Invalid argument
2 DEFB $06 ; Class-06 - A numeric expression must follow.
2 DEFB $05 ; Error Report: Number too big
2 DEFB $02 ;;delete x, y, yy.
2 DEFB $02 ;;delete x, y, r.
2 DEFB $02 ;;delete .
2 DEFB $01 ;;exchange y, x.
2 DEFB $01 ; Error Report: Variable not found
2 DEC HL ; point to exponent
2 DEC HL ; now end of VARS area.
2 DEC HL ; next location down
2 DEC HL ; adjust
2 DEC A ; decrease
2 CP D ; compare with parameter
2 CP B ;
2 CP (HL) ; does the main key code match ?
2 CP (HL) ; compare with that in workspace.
2 CP $CC ; is it 'TO' ?
2 CP $80 ; is it the end-marker ?
2 CP $2C ; is it a comma ?
2 CP $2C ; is character ',' ?
2 CP $29 ; is it the closing ')' ?
2 CP $29 ; is character a ')' ?
2 CP $29 ; is character ')' ?
2 CP $28 ; is character '(' ?
2 CP $20 ; is it a space ?
2 CP $18 ; is it symbol shift ?
2 CP $08 ; compare with 8
2 CP $03 ; is it MERGE ?
2 CCF ; complement carry flag.
2 CALL <A href="#L34E9">L34E9</a> ; routine TEST-ZERO
2 CALL <A href="#L33B4">L33B4</a> ; routine STACK-NUM
2 CALL <A href="#L3004">L3004</a> ; routine ADD-BACK
2 CALL <A href="#L2F9B">L2F9B</a> ; routine PREP-ADD
2 CALL <A href="#L2F8B">L2F8B</a> ; routine CA-10*A+C
2 CALL <A href="#L2D4F">L2D4F</a> ; routine E-TO-FP
2 CALL <A href="#L22E5">L22E5</a> ; routine PLOT-SUB
2 CALL <A href="#L1FC3">L1FC3</a> ; routine UNSTACK-Z quits if checking syntax.
2 CALL <A href="#L1C1F">L1C1F</a> ; routine CLASS-01 returns destination
2 CALL <A href="#L196E">L196E</a> ; routine LINE-ADDR gets address in HL.
2 CALL <A href="#L192A">L192A</a> ; routine OUT-SP-NO
2 CALL <A href="#L0D4D">L0D4D</a> ; routine TEMPS applies permanent attributes,
2 CALL <A href="#L05E7">L05E7</a> ; routine LD-EDGE-1
2 CALL <A href="#L05E3">L05E3</a> ; routine LD-EDGE-2
2 CALL <A href="#L0333">L0333</a> ; routine K-DECODE
2 BIT 7,C ; checking syntax ?
2 BIT 0,(IY+$02) ; test TV_FLAG - lower screen in use ?
2 AND D ;
2 AND A ; test for zero
2 AND A ; is it zero ?
2 AND (HL) ;
2 ADD HL,HL ; multiply
2 ADD HL,HL ; by
2 ADC HL,DE ;
2 ;;;
2 ; variable
2 ; to BC and A.
2 ; system variables.
2 ; statement.
2 ; screen.
2 ; routine.
2 ; raise 'Number too big'.
2 ; parameters.
2 ; on the calculator stack.
2 ; no jump to be made.
2 ; mem-4 ; sin(a) const
2 ; mem-3 ; cos(a) const
2 ; line.
2 ; is being checked.
2 ; follow.
2 ; expression.
2 ; end-marker.
2 ; clearing
2 ; channel.
2 ; argument.
2 ; address.
2 ; address of variable to be assigned.
2 ; --
2 ; 'Variable not found'
2 ; 'Tape loading error'
2 ; 'Subscript error'
2 ; 'Parameter error'
2 ; 'Invalid colour'.
2 ; 'Integer out of range'
2 ; A (HL)
2 ; tx, ty, ax, ay.
1 X1349: XOR A ; clear accumulator to directly
1 X0F85: LD HL,($5C5B) ; fetch address of keyboard cursor from K_CUR
1 X08CE LD DE,($5C53) ; set DE from system variable PROG.
1 X007B: LD A,(HL) ; load character to A from HL.
1 L3D00: DEFB %00000000
1 L386E: DEFB $FF, $FF ;
1 L386C: DEFB $38 ;;end-calc last value is 1 or 0.
1 L386A: DEFB $02 ;;delete .
1 L385D: DEFB $02 ;;delete Y.
1 L3851: RST 28H ;; FP-CALC X, Y.
1 L384A: RST 28H ;; FP-CALC
1 L3843: RST 28H ;; FP-CALC x.
1 L3833: RST 28H ;; FP-CALC x.
1 L37FA: DEFB $01 ;;exchange
1 L37F8: RST 28H ;; FP-CALC
1 L37E2: CALL <A href="#L3297">L3297</a> ; routine re-stack
1 L37DA: RST 28H ;; FP-CALC x.
1 L37B7: DEFB $31 ;;duplicate
1 L37B5: RST 28H ;; FP-CALC angle in radians
1 L37AA: RST 28H ;; FP-CALC angle in radians.
1 L37A8: DEFB $38 ;;end-calc quadrants II and III correct.
1 L37A1: DEFB $A1 ;;stk-one Y, Z, 1.
1 L3783: RST 28H ;; FP-CALC X.
1 L373D: DEFB $01 ;;exchange
1 L371C: DEFB $A0 ;;stk-zero <font color=#9900FF>Note.</font> not
1 L371A: RST 08H ; ERROR-1
1 L3713: RST 28H ;; FP-CALC
1 L370E: RST 28H ;; FP-CALC
1 L370C: LD (HL),A ;
1 L3705: JR C,<A href="#L370E">L370E</a> ; to RSLT-ZERO
1 L3703: RST 08H ; ERROR-1
1 L36C4: RST 28H ;; FP-CALC
1 L36C2: DEFB $38 ;;end-calc -4.
1 L36B7: DEFB $31 ;;duplicate -3.4, -3.4.
1 L36AF: RST 28H ;; FP-CALC x. (= 3.4 or -3.4).
1 L36A0: RST 28H ;; FP-CALC 17, 3.
1 L369B: POP AF ; Drop the calculator return address RE-ENTRY
1 L368F: INC DE ; Collect the
1 L3687: LD E,(HL) ; the jump byte 0-127 forward, 128-255 back.
1 L3686: EXX ; switch in pointer set
1 L367A: EXX ; switch in set that addresses code
1 L3674: CALL <A href="#L2BF1">L2BF1</a> ; Routine STK-FETCH to fetch and delete the
1 L3671: JP <A href="#L2D28">L2D28</a> ; jump back to STACK-A (with memory check)
1 L3669: CALL <A href="#L2BF1">L2BF1</a> ; routine STK-FETCH to fetch and delete the
1 L365F: CALL <A href="#L2AB2">L2AB2</a> ; routine STK-STO-$ stacks the string
1 L3645: CALL <A href="#L1E94">L1E94</a> ; routine FIND-INT1 fetches stream to A
1 L361F: LD BC,$0001 ; create an initial byte in workspace
1 L360C: JP NZ,<A href="#L1C8A">L1C8A</a> ; jump back to REPORT-C with a result mismatch.
1 L35DE: LD HL,($5C5D) ; fetch value of system variable CH_ADD
1 L35DC: RST 08H ; ERROR-1
1 L35C9: CALL <A href="#L2DD5">L2DD5</a> ; routine FP-TO-A puts the number in A.
1 L35BF: LD HL,($5C65) ; fetch STKEND value from system variable.
1 L35B7: POP BC ; now second length
1 L359C: CALL <A href="#L2BF1">L2BF1</a> ; routine STK-FETCH fetches string parameters
1 L358C: POP AF ; pop carry - will be set if eql/neql
1 L3588: PUSH AF ; save A and carry
1 L3585: POP BC ; discard length
1 L3575: OR C ; test the length of first string.
1 L3572: POP AF ; restore carry - set for eql/neql
1 L356B: POP BC ; pop the second length off stack.
1 L3564: LD A,H ; test if the second string
1 L3559: RRCA ; 2nd RRCA causes eql/neql to set carry.
1 L354E: BIT 2,A ; test if a string comparison.
1 L3543: RRCA ; the first RRCA sets carry for a swap.
1 L353B: LD A,B ; transfer literal to accumulator.
1 L352D: EX DE,HL ; make HL point to the number.
1 L3524: EX DE,HL ; make HL address second operand.
1 L351B: EX DE,HL ; make HL point to second number
1 L350B: PUSH HL ; save pointer to the first byte
1 L3507: INC HL ; address 2nd byte.
1 L3506: XOR A ; set XOR mask to zero
1 L3501: CALL <A href="#L34E9">L34E9</a> ; routine TEST-ZERO sets carry if zero
1 L34F9: CALL <A href="#L34E9">L34E9</a> ; routine TEST-ZERO
1 L34E9: PUSH HL ; preserve HL which is used to address.
1 L34E7: RST 08H ; ERROR-1
1 L34E4: JP <A href="#L2D2B">L2D2B</a> ; jump back and exit via STACK-BC to store
1 L34D3: DEC A ; make range of bits 0-4 start at zero
1 L34BC: CALL <A href="#L2BF1">L2BF1</a> ; routine STK-FETCH fetches the string
1 L34B3: CALL <A href="#L1E99">L1E99</a> ; routine FIND-INT2 to fetch the
1 L34B0: JP <A href="#L2D28">L2D28</a> ; exit via STACK-A to put the value on the
1 L34AC: CALL <A href="#L1E99">L1E99</a> ; routine FIND-INT2 puts address in BC.
1 L34A5: CALL <A href="#L1E99">L1E99</a> ; Routine FIND-INT2 puts port address in BC.
1 L3492: CALL <A href="#L34E9">L34E9</a> ; call routine TEST-ZERO and
1 L3483: PUSH DE ; save STKEND.
1 L3474: LD A,(HL) ; load first byte and
1 L346E: CALL <A href="#L34E9">L34E9</a> ; call routine TEST-ZERO and
1 L346A: LD B,$FF ; signal abs
1 L3453: DEFB $31 ;;duplicate v,v.
1 L3449: LD B,A ; parameter $00 - $1F to B counter
1 L343E: LD A,(DE) ; each byte of second
1 L343C: LD B,$05 ; there are five bytes to be swapped
1 L342D: PUSH HL ; save the result pointer.
1 L341B: LD H,D ; save STKEND - required for result
1 L340F: PUSH DE ; save STKEND
1 L3406: LD C,A ; store the original number $00-$1F.
1 L33F8: RET Z ; return if zero. >>
1 L33F7: AND A ; test if initially zero.
1 L33F1: DEC B ; decrement B counter
1 L33DE: ADD A,$50 ; now add $50 to form actual exponent
1 L33C8: CALL <A href="#L33A9">L33A9</a> ; routine TEST-5-SP tests that room exists
1 L33C6: LD H,D ; transfer STKEND
1 L33C0: CALL <A href="#L33A9">L33A9</a> ; routine TEST-5-SP test free memory
1 L33B4: LD DE,($5C65) ; Load destination from STKEND system variable.
1 L33A9: PUSH DE ; save
1 L33A2: POP AF ; drop return address.
1 L33A1: RET ; return - indirect jump if from above.
1 L338E: LD DE,<A href="#L32D7">L32D7</a> ; Address: tbl-addrs
1 L338C: RLCA ; double the literal
1 L3380: CP $18 ; compare with first unary operations.
1 L336C: PUSH HL ; save pointer on stack
1 L3365: LD ($5C65),DE ; save end of stack in system variable STKEND
1 L3362: EXX ; switch sets
1 L335E: LD A,B ; fetch the Z80 B register to A
1 L335B: CALL <A href="#L35BF">L35BF</a> ; routine STK-PNTRS is called to set up the
1 L32D7: DEFW <A href="#L368F">L368F</a> ; $00 Address: $368F - jump-true
1 L32D3: DEFB $40 ;;Bytes: 2
1 L32CE: DEFB $F1 ;;Exponent: $81, Bytes: 4
1 L32CC: DEFB $30 ;;Exponent: $80, Bytes: 1
1 L32C8: DEFB $40 ;;Bytes: 2
1 L32C5: DEFB $00 ;;Bytes: 1
1 L32BD: DEC HL ; address 3rd byte
1 L32B2: DEC B ; decrease exponent
1 L32B1: EX DE,HL ; integer to HL, addr of 4th byte to DE.
1 L3297: LD A,(HL) ; Fetch Exponent byte to A
1 L3296: EX DE,HL ; swap pointers
1 L3293: CALL <A href="#L3296">L3296</a> ; routine RESTK-SUB below and continue
1 L3290: EX DE,HL ;
1 L328A: SLA A ;
1 L3283: AND $07 ;
1 L327E: LD (HL),$00 ;
1 L3272: PUSH DE ;
1 L326D: SUB $A0 ;
1 L326C: LD A,(HL) ;
1 L3267: CALL <A href="#L2D8E">L2D8E</a> ; routine INT-STORE
1 L3261: SRL D ;
1 L325E: JR Z,<A href="#L3267">L3267</a> ; to T-STORE
1 L3252: SET 7,D ;
1 L323F: JR NC,<A href="#L326D">L326D</a> ; to X-LARGE
1 L3233: DEC HL ;
1 L3221: CP $91 ;
1 L3214: LD A,(HL) ;
1 L31FA: INC B ;
1 L31F9: SCF ; Set Carry Flag
1 L31F2: AND A ;
1 L31E2: SBC HL,DE ;
1 L31DB: ADD HL,HL ;
1 L31D2: RLA ;
1 L31AF: CALL <A href="#L3293">L3293</a> ; routine RE-ST-TWO
1 L31AD: RST 08H ; ERROR-1
1 L3195: PUSH HL ;
1 L3186: RLA ;
1 L316E: EXX ;
1 L316C: LD B,$20 ;
1 L315E: EXX ;
1 L315D: XOR A ;
1 L3159: LD A,$80 ;
1 L3155: JR NC,<A href="#L316C">L316C</a> ; to NORMALISE
1 L3151: LD (HL),A ;
1 L3146: INC A ;
1 L313D: RLA ;
1 L313B: DEC A ;
1 L3125: EXX ;
1 L311B: EXX ;
1 L3114: JR NC,<A href="#L311B">L311B</a> ; to NO-ADD
1 L30F0: CALL <A href="#L3293">L3293</a> ; routine RE-ST-TWO
1 L30EF: POP DE ;
1 L30EA: CALL <A href="#L2D8E">L2D8E</a> ; routine INT-STORE
1 L30CA: LD A,(DE) ;
1 L30C0: CALL <A href="#L34E9">L34E9</a> ; routine TEST-ZERO preserves accumulator.
1 L30BE: POP BC ; restore preserved BC
1 L30BC: DJNZ <A href="#L30B1">L30B1</a> ; back to HL-LOOP for all 16 bits
1 L30B1: ADD HL,HL ; double result
1 L30A9: PUSH BC ; preserve BC throughout
1 L30A5: XOR A ;
1 L30A3: LD D,A ;
1 L309F: JP Z,<A href="#L31AD">L31AD</a> ; to REPORT-6
1 L307C: EXX ;
1 L3055: PUSH AF ;
1 L303E: CALL <A href="#L3293">L3293</a> ; routine RE-ST-TWO
1 L303C: DEC HL ;
1 L3014: LD A,(DE) ; fetch first byte of second
1 L300F: EX DE,HL ; address second number with HL
1 L300D: EXX ;
1 L3004: INC E ;
1 L2FFB: LD L,$00 ;
1 L2FF9: EXX ;
1 L2FE5: EXX ;
1 L2FDD: AND A ;
1 L2FBA: PUSH HL ; save pointer to first number, result if math.
1 L2FAF: DEC HL ; work from LSB to MSB
1 L2F9B: LD A,(HL) ; pick up exponent
1 L2F8B: PUSH DE ; preserve DE.
1 L2F85: RST 10H ; PRINT-A outputs the sign
1 L2F83: LD A,$2B ; prepare character '+'
1 L2F6C: LD D,B ; counter to D
1 L2F64: RST 10H ; PRINT-A outputs the character '.' or '0'
1 L2F5E: LD A,C ; fetch total digits and
1 L2F59: CALL <A href="#L15EF">L15EF</a> ; routine OUT-CODE outputs it.
1 L2F52: LD A,C ; fetch total digit count
1 L2F4A: XOR A ;
1 L2F46: AND A ; test for zero leading digits as in .123
1 L2F2D: LD (IY+$71),B ; MEM-5-1st
1 L2F25: DJNZ <A href="#L2F18">L2F18</a> ; loop back to PF-RND-LP
1 L2F18: DEC HL ; address digit at rounding position.
1 L2F0C: PUSH AF ; save A and flags
1 L2EEF: LD A,E ;
1 L2EEC: LD BC,$0200 ;
1 L2EDF: LD A,(IY+$71) ; MEM-5-1st
1 L2ECF: EX DE,HL ;
1 L2ECB: RST 28H ;; FP-CALC int x.
1 L2EB8: DJNZ <A href="#L2EA1">L2EA1</a> ; decrement the nibble count, back to PF-DIGITS
1 L2EB3: BIT 0,B ; test if the nibble count is even
1 L2EA9: LD (DE),A ; insert digit at destination
1 L2EA1: RLD ; pick up leftmost nibble from (HL)
1 L2E8A: LD A,(HL) ; fetch 0 or prev value
1 L2E7B: SLA E ; C<xxxxxxxx<0
1 L2E6F: EX DE,HL ;
1 L2E56: SUB $80 ; make exponent positive
1 L2E25: DEFB $E2 ;;get-mem-2 int x = 0, x-int x.
1 L2E24: RST 28H ;; FP-CALC int x = 0.
1 L2E1E: PUSH DE ; save the part before decimal point.
1 L2E01: RST 28H ;; FP-CALC
1 L2DF8: DEFB $A0 ;;stk-zero x,0. begin by
1 L2DF2: DEFB $2A ;;abs
1 L2DE3: RST 28H ;; FP-CALC
1 L2DE1: POP AF ; restore value and success flag and
1 L2DD5: CALL <A href="#L2DA2">L2DA2</a> ; routine FP-TO-BC returns with C in A also.
1 L2DC1: LD D,A ; store a copy of A in D.
1 L2DAD: RST 28H ;; FP-CALC
1 L2DA2: RST 28H ;; FP-CALC set HL to
1 L2D8E: PUSH HL ; preserve HL
1 L2D8C: LD C,$00 ; make sign byte positive and continue
1 L2D7F: INC HL ; skip zero indicator.
1 L2D7B: RST 28H ;; FP-CALC final x, factor.
1 L2D71: JR Z,<A href="#L2D7B">L2D7B</a> ; forward to E-END if A emptied of bits
1 L2D6E: DEFB $E1 ;;get-mem-1 x/10 or x*10, 10.
1 L2D6D: DEFB $05 ;;division x/10.
1 L2D60: SRL A ; 0>76543210>C
1 L2D55: PUSH AF ; save positive exp and sign in carry
1 L2D4F: RLCA ; this will set the x.
1 L2D40: CALL <A href="#L2D22">L2D22</a> ; routine STK-DIGIT puts 0-9 on stack
1 L2D3B: PUSH AF ; save first character
1 L2D2B: LD IY,$5C3A ; re-initialize ERR_NR
1 L2D28: LD C,A ; transfer to C
1 L2D22: CALL <A href="#L2D1B">L2D1B</a> ; routine NUMERIC
1 L2D1B: CP $30 ; '0'
1 L2D18: JP <A href="#L2D4F">L2D4F</a> ; JUMP forward to E-TO-FP to assign to
1 L2CFF: CALL <A href="#L2D1B">L2D1B</a> ; routine NUMERIC
1 L2CFE: RST 20H ; NEXT-CHAR
1 L2CF2: LD B,$FF ; initialize temporary sign byte to $FF
1 L2CEB: CP $45 ; is character 'E' ?
1 L2CDA: RST 18H ; GET-CHAR
1 L2CD5: RST 28H ;; FP-CALC
1 L2CCF: JP C,<A href="#L1C8A">L1C8A</a> ; to REPORT-C if just a '.'
1 L2CCB: RST 20H ; NEXT-CHAR
1 L2CB8: CP $2E ; '.' - leading decimal point ?
1 L2CB3: LD B,D ; transfer 16 bit buffer
1 L2CA2: RST 20H ; NEXT-CHAR
1 L2C9B: CP $C4 ; 'BIN' token ?
1 L2C8D: CP $41 ; less than 'A' ?
1 L2C88: CALL <A href="#L2D1B">L2D1B</a> ; routine NUMERIC will reset carry if so.
1 L2C7F: POP BC ; pop a dimension size ***
1 L2C7C: POP BC ; pop the data length
1 L2C2E: RST 20H ; NEXT-CHAR
1 L2C2D: EX DE,HL ; save the element size in DE.
1 L2C1F: SET 7,C ; signal array.
1 L2C15: JR C,<A href="#L2C1F">L2C1F</a> ; skip to D-LETTER if variable did not exist.
1 L2C05: JP NZ,<A href="#L1C8A">L1C8A</a> ; jump to REPORT-C if a long-name variable.
1 L2C02: CALL <A href="#L28B2">L28B2</a> ; routine LOOK-VARS
1 L2BF1: LD HL,($5C65) ; STKEND
1 L2BEA: DEC HL ; address variable name
1 L2BC6: PUSH AF ; save first character and mask.
1 L2BC0: LD A,$DF ; indicator mask %11011111 for
1 L2BAF: DEC HL ; point to high byte of length.
1 L2BA6: EX DE,HL ; exchange pointers HL=STKEND DE=end of vars.
1 L2BA3: POP BC ; pop the new length. (*)
1 L2B9B: EX (SP),HL ; (*) length to stack, pointer to HL.
1 L2B72: LD HL,($5C4D) ; fetch DEST to HL.
1 L2B66: BIT 6,(IY+$01) ; test FLAGS - numeric or string result ?
1 L2B59: PUSH HL ; save the pointer.
1 L2B4F: LD HL,($5C4D) ; fetch DEST - HL addresses first character.
1 L2B3E: INC HL ; increase pointer.
1 L2B29: LD A,C ; save length lo in A.
1 L2B1F: CALL <A href="#L2C88">L2C88</a> ; routine ALPHANUM sets carry if alphanumeric
1 L2B0C: INC HL ; increase pointer.
1 L2B0B: INC BC ; increase byte count for each relevant
1 L2AFF: LD HL,($5C4D) ; fetch system variable DEST to HL.
1 L2AF4: CALL <A href="#L2530">L2530</a> ; routine SYNTAX-Z.
1 L2AEE: EX DE,HL ;
1 L2AEB: POP HL ; restore the limit.
1 L2AE8: LD A,D ; move flag to accumulator $00 or $FF.
1 L2ACD: PUSH DE ; preserve DE register throughout.
1 L2ACC: XOR A ; set result flag to zero.
1 L2AB6: PUSH BC ; save two registers
1 L2AB2: RES 6,(IY+$01) ; update FLAGS - signal string result.
1 L2AB1: XOR A ; clear to signal a sliced string or element.
1 L2AAD: CALL <A href="#L2530">L2530</a> ; routine SYNTAX-Z (UNSTACK-Z?)
1 L2AA8: POP DE ; restore start address from machine stack ***
1 L2A94: POP AF ; pop the running flag.
1 L2A81: PUSH HL ; save limit length.
1 L2A7A: JP NZ,<A href="#L1C8A">L1C8A</a> ; jump to REPORT-C with anything else
1 L2A52: CALL <A href="#L2530">L2530</a> ; routine SYNTAX-Z
1 L2A49: CP $28 ; is character '(' ?
1 L2A48: RST 20H ; NEXT-CHAR
1 L2A45: CALL <A href="#L2A52">L2A52</a> ; routine SLICING slices the string.
1 L2A2C: CALL <A href="#L2AEE">L2AEE</a> ; routine DE,(DE+1) gets final dimension
1 L2A22: RST 20H ; NEXT-CHAR moves CH_ADD to next statement
1 L2A20: RST 08H ; ERROR-1
1 L2A12: JR NZ,<A href="#L2A7A">L2A7A</a> ; forward to SL-RPT-C if so
1 L29FB: PUSH BC ; save dimension number.
1 L29EA: PUSH HL ; save the data pointer.
1 L29E7: LD HL,$0000 ; initialize data pointer to zero.
1 L29E0: RST 18H ; GET-CHAR
1 L29D8: CP $29 ; as above ')' could follow the expression
1 L29C3: PUSH HL ; save counter
1 L29C0: EX DE,HL ; save dimension pointer in DE
1 L29AE: INC HL ; step past
1 L29A1: INC HL ; address length low
1 L2996: XOR A ; clear A
1 L2991: POP DE ; discard
1 L2981: BIT 5,C ; test if numeric
1 L296B: LD A,B ; transfer found variable letter to A.
1 L295A: LD A,(HL) ; fetch character again.
1 L2951: LD HL,($5C0B) ; set HL to DEFADD
1 L294B: POP HL ; pop the pointer to first character in
1 L2943: CALL <A href="#L2C88">L2C88</a> ; routine ALPHANUM
1 L293F: POP DE ; discard pointer to 2nd prog char v2
1 L293E: POP DE ; discard pointer to first var letter
1 L2934: POP DE ; discard the pointer to 2nd. character v2
1 L2932: SET 7,B ; will signal not found
1 L292A: PUSH BC ; save flags
1 L2929: POP HL ; pop saved pointer to char 1
1 L2913: LD A,(DE) ; pick up letter from prog area
1 L2912: INC HL ; address next character in vars area
1 L2900: LD A,(HL) ; get first character
1 L28FD: LD HL,($5C4B) ; set HL to start of variables from VARS
1 L28EF: LD B,C ; save flags in B
1 L28E3: LD A,($5C0C) ; load A with DEFADD_hi
1 L28DE: RST 20H ; NEXT-CHAR advances past '$'
1 L28D4: CALL <A href="#L2C88">L2C88</a> ; routine ALPHANUM
1 L28B2: SET 6,(IY+$01) ; update FLAGS - presume numeric result
1 L28AB: INC HL ; increase pointer
1 L288D: POP DE ; location of ')' in DEF FN to DE.
1 L288B: RST 08H ; ERROR-1
1 L2885: PUSH HL ; save location of ')' in DEF FN
1 L2852: INC HL ; now address first of 5-byte location.
1 L2843: INC HL ; point to next character.
1 L2831: AND A ; test A ( will be zero if string '$' - '$' )
1 L2825: POP HL ; restore search point.
1 L2814: PUSH HL ; save address of DEF FN
1 L2812: RST 08H ; ERROR-1
1 L2808: LD DE,$00CE ; search is for token 'DEF FN' in E,
1 L2802: RST 20H ; NEXT-CHAR advances to start of argument
1 L27F7: RST 20H ; NEXT-CHAR fetches name
1 L27F4: JP <A href="#L2712">L2712</a> ; jump back to S-CONT-2 to continue scanning.
1 L27E9: RST 20H ; NEXT-CHAR
1 L27E6: JP NZ,<A href="#L1C8A">L1C8A</a> ; jump to REPORT-C
1 L27E4: CP $29 ; is character the closing ')' ?
1 L27D9: CALL <A href="#L24FB">L24FB</a> ; routine SCANNING checks each argument
1 L27D0: CP $28 ; is '(' ?
1 L27BD: CALL <A href="#L2530">L2530</a> ; routine SYNTAX-Z
1 L27B0: DEFB $06 ; '-' opcode $C3
1 L2795: DEFB '+', $CF ; $C0 + 'addition'
1 L2790: PUSH BC ; now save this priority/operation on stack
1 L2788: JR C,<A href="#L2761">L2761</a> ; back to S-RPORT-C2 if less
1 L2773: PUSH DE ; save high priority op on stack again
1 L2770: POP BC ; fetch the previous priority/operation
1 L2764: POP DE ; fetch the last operation from stack
1 L2761: JP NZ,<A href="#L1C8A">L1C8A</a> ; to REPORT-C if mismatch
1 L275B: LD A,E ; fetch the operation code to accumulator
1 L2758: DEFB $38 ;;end-calc
1 L274C: PUSH DE ; now stack this priority/operation
1 L2734: POP DE ; fetch last priority and operation
1 L2723: LD B,$00 ; prepare to add
1 L2713: CP $28 ; is it '(' ?
1 L2712: RST 18H ; GET-CHAR
1 L270D: PUSH BC ; push the priority and calculator operation
1 L2707: CP $EE ; compare 'str$'
1 L26DF: LD BC,$09DB ; prepare priority 09, operation code $C0 +
1 L26DD: JR <A href="#L2712">L2712</a> ; forward to S-CONT-2 ===>
1 L26C9: CALL <A href="#L28B2">L28B2</a> ; routine LOOK-VARS
1 L26C3: SET 6,(IY+$01) ; update FLAGS - Signal numeric result
1 L26B6: INC HL ; advance pointer
1 L26B5: RST 18H ; GET-CHAR positions HL at digit.
1 L268D: CALL <A href="#L2530">L2530</a> ; routine SYNTAX-Z
1 L2684: CALL <A href="#L2C88">L2C88</a> ; routine ALPHANUM checks if variable or
1 L267B: CALL <A href="#L2522">L2522</a> ; routine S-2-COORD
1 L2672: CALL <A href="#L2522">L2522</a> ; routine S-2-COORD
1 L2668: CALL <A href="#L2522">L2522</a> ; routine S-2-COORD
1 L2665: JP <A href="#L2712">L2712</a> ; to S-CONT-2 ===>
1 L2660: LD B,$00 ; set high byte of length to zero
1 L2634: LD BC,$105A ; priority $10, operation code $1A ('read-in')
1 L2630: RST 20H ; NEXT-CHAR
1 L2627: CALL <A href="#L2530">L2530</a> ; routine SYNTAX-Z
1 L2625: JR <A href="#L2630">L2630</a> ; forward to S-PI-END
1 L25F8: CALL <A href="#L2530">L2530</a> ; routine SYNTAX-Z
1 L25F5: JP <A href="#L27BD">L27BD</a> ; jump forward to S-FN-SBRN.
1 L25E8: RST 20H ; NEXT-CHAR
1 L25DB: LD HL,$5C3B ; Address FLAGS system variable.
1 L25D9: DEC BC ; decrease count by 1.
1 L25CB: LD A,(HL) ; fetch a character from source.
1 L25BE: CALL <A href="#L250F">L250F</a> ; routine S-QUOTE-S copies string until a
1 L25B3: RST 18H ; GET-CHAR
1 L25AF: RST 20H ; NEXT-CHAR just ignore
1 L2596: DEFB $22, <A href="#L25B3">L25B3</a>-$-1 ; $1C offset to S-QUOTE
1 L2580: CALL <A href="#L2307">L2307</a> ; routine STK-TO-BC fetches line to C,
1 L257D: JP <A href="#L2AB2">L2AB2</a> ; to STK-STO-$ to store the string in
1 L2573: POP HL ; restore the last bitmap start
1 L255D: INC D ; increment screen address.
1 L255A: LD C,A ; load C with inverse mask $00 or $FF
1 L254F: PUSH BC ; save count
1 L2535: CALL <A href="#L2307">L2307</a> ; routine STK-TO-BC.
1 L2530: BIT 7,(IY+$01) ; test FLAGS - checking syntax only ?
1 L252D: JP NZ,<A href="#L1C8A">L1C8A</a> ; jump back to REPORT-C if not.
1 L2522: RST 20H ; NEXT-CHAR
1 L250F: CALL <A href="#L0074">L0074</a> ; routine CH-ADD+1 points to next character
1 L24FF: LD C,A ; store the character while a look up is done.
1 L24FB: RST 18H ; GET-CHAR
1 L24F9: RST 08H ; ERROR-1
1 L24F7: JR Z,<A href="#L24EC">L24EC</a> ; to D-L-PLOT
1 L24EC: DEC A ;
1 L24DF: LD HL,($5C7D) ; COORDS
1 L24DB: LD C,A ;
1 L24D4: SUB H ;
1 L24CE: ADD A,L ;
1 L24CB: LD H,B ;
1 L24C4: OR C ;
1 L24B7: CALL <A href="#L2307">L2307</a> ; routine STK-TO-BC
1 L2497: PUSH AF ; Save the line count (A) on the machine stack.
1 L2495: LD A,$FC ; Use a value of 252 (for arc).
1 L247D: RST 28H ;; FP-CALC z.
1 L2477: CALL <A href="#L24B7">L24B7</a> ; routine DRAW-LINE draws to the relative
1 L245F: RST 28H ;; FP-CALC tx, ty, ax, ay.
1 L2439: PUSH BC ; Preserve the arc counter on the machine stack.
1 L2425: RST 28H ;; FP-CALC
1 L2420: DEC B ; decrement the arc count (4,8,12,16...).
1 L23C1: CALL <A href="#L247D">L247D</a> ; routine CD-PRMS1
1 L23A3: DEFB $C0 ;;st-mem-0 x, y, sin(A/2). store mem-0
1 L238D: RST 20H ; NEXT-CHAR skips over the 'comma'.
1 L2382: RST 18H ; GET-CHAR
1 L235A: RST 28H ;; FP-CALC x, y, r, hc.
1 L233B: RST 28H ;; FP-CALC x, y, r
1 L2320: RST 18H ; GET-CHAR x, y.
1 L2314: CALL <A href="#L2DD5">L2DD5</a> ; routine FP-TO-A compresses last value into
1 L2307: CALL <A href="#L2314">L2314</a> ; routine STK-TO-A
1 L2303: LD (HL),A ; load byte to the screen.
1 L22FD: BIT 2,C ; is it inverse 1 ?
1 L22F0: RRCA ; rotate mask.
1 L22E5: LD ($5C7D),BC ; store new x/y values in COORDS
1 L22DC: CALL <A href="#L2307">L2307</a> ; routine STK-TO-BC
1 L22D4: RLCA ; rotate and loop back
1 L22CB: CALL <A href="#L2307">L2307</a> ; routine STK-TO-BC
1 L22AA: LD A,$AF ; load with 175 decimal.
1 L22A6: LD ($5C48),A ; update BORDCR with new paper/ink
1 L2294: CALL <A href="#L1E94">L1E94</a> ; routine FIND-INT1
1 L2287: LD A,C ; value to A
1 L227D: LD C,A ; store value in C
1 L2273: SBC A,A ; set zero flag for bright.
1 L226C: XOR (HL) ; impress bits specified
1 L2258: LD A,C ; load colour to A
1 L2257: LD C,A ; save A in C
1 L2246: LD HL,$5C8F ; address system variable ATTR_T initially.
1 L2244: RST 08H ; ERROR-1
1 L223E: LD C,A ; value to C
1 L2234: LD A,D ; fetch parameter
1 L2228: LD C,A ; save the A
1 L2211: SUB $11 ; reduce range $FF-$04
1 L21FC: SUB $C9 ; reduce to control character $10 (INK)
1 L21F2: CP $D9 ; is it 'INK' ?
1 L21E2: CALL <A href="#L21F2">L21F2</a> ; routine CO-TEMP-3 to output colour control.
1 L21E1: RST 20H ; NEXT-CHAR
1 L21D6: LD HL,($5C51) ; fetch address of current channel CURCHL
1 L21D4: RST 08H ; ERROR-1
1 L21D0: CALL <A href="#L2530">L2530</a> ; routine SYNTAX-Z (UNSTACK-Z?)
1 L21CE: RST 08H ; ERROR-1
1 L21B9: LD HL,($5C61) ; fetch WORKSP start of input
1 L21B2: CALL <A href="#L204E">L204E</a> ; routine PR-POSN-1 handles a position item.
1 L21AF: CALL <A href="#L1FFC">L1FFC</a> ; routine PR-ITEM-1 considers further items.
1 L219B: LD HL,($5C63) ; STKBOT points to the end of the input.
1 L2174: LD HL,$5C71 ; point HL to FLAGX
1 L2161: LD (IY+$22),$00 ; set K_CUR_hi to a low value so that the cursor
1 L215E: CALL <A href="#L0F2C">L0F2C</a> ; routine EDITOR is called for input
1 L2148: LD HL,($5C61) ; set HL to WORKSP - start of workspace.
1 L213A: LD HL,<A href="#L213A">L213A</a> ; address: IN-VAR-1 - this address
1 L2129: LD ($5C5B),HL ; set keyboard cursor K_CUR to HL
1 L211C: RST 30H ; BC-SPACES opens 1 or 3 bytes in workspace
1 L211A: OR (HL) ; if numeric result, set bit 6 of FLAGX.
1 L20FA: CALL <A href="#L2530">L2530</a> ; routine SYNTAX-Z
1 L20ED: CALL <A href="#L2C8D">L2C8D</a> ; routine ALPHA checks if character is
1 L20D8: CP $CA ; is the character the token 'LINE' ?
1 L20C1: CALL <A href="#L204E">L204E</a> ; routine PR-POSN-1 deals with a single
1 L20AD: LD ($5C88),BC ; set S_POSN update upper screen line/column.
1 L2096: LD (IY+$02),$01 ; update TV_FLAG - signal lower screen in use
1 L2089: CALL <A href="#L2530">L2530</a> ; routine SYNTAX-Z to check if in runtime.
1 L2070: CP $23 ; is character '#' ?
1 L206E: CP A ; reset the zero flag.
1 L2067: RST 20H ; NEXT-CHAR to A.
1 L2061: CP $27 ; is character a "'" ? (newline)
1 L204E: RST 18H ; GET-CHAR
1 L2048: CP $0D ; is it a carriage return ?
1 L2045: CP $29 ; is character a ')' ?
1 L203C: LD A,B ; this tests if the
1 L2024: CALL <A href="#L21F2">L21F2</a> ; routine CO-TEMP-3 will print any colour
1 L201E: RST 10H ; PRINT-A outputs the control
1 L200E: CP $AD ; is character 'TAB' ?
1 L1FFC: RST 18H ; GET-CHAR
1 L1FF5: CALL <A href="#L1FC3">L1FC3</a> ; routine UNSTACK-Z
1 L1FF2: CP $29 ; return now if this is ')' from input-item.
1 L1FE5: CALL <A href="#L204E">L204E</a> ; routine PR-POSN-1 returns zero if more
1 L1FDF: RST 18H ; GET-CHAR gets printable character
1 L1FCF: CALL <A href="#L2530">L2530</a> ; routine SYNTAX-Z checks if program running
1 L1FCD: LD A,$02 ; the stream for the upper screen.
1 L1FC9: LD A,$03 ; the printer channel
1 L1FC3: CALL <A href="#L2530">L2530</a> ; routine SYNTAX-Z sets zero flag if syntax
1 L1FBD: JP NZ,<A href="#L1C8A">L1C8A</a> ; jump back to REPORT-C if the expected result
1 L1FA6: CP $29 ; should close with a ')'
1 L1F94: EX DE,HL ; bring back pointer.
1 L1F89: JP NC,<A href="#L1C8A">L1C8A</a> ; to REPORT-C if not
1 L1F86: CALL <A href="#L2C8D">L2C8D</a> ; routine ALPHA checks that it is the expected
1 L1F7D: CP $28 ; is it '(' ?
1 L1F6A: SET 6,(IY+$01) ; set FLAGS - Assume numeric result
1 L1F60: CALL <A href="#L2530">L2530</a> ; routine SYNTAX-Z
1 L1F54: LD A,$7F ; Input address: $7FFE
1 L1F4F: RES 5,(IY+$01) ; update FLAGS - signal no new key
1 L1F49: BIT 5,(IY+$01) ; test FLAGS - has a new key been pressed ?
1 L1F3D: HALT ; wait for interrupt.
1 L1F3A: CALL <A href="#L1E99">L1E99</a> ; routine FIND-INT2 puts value in BC
1 L1F36: PUSH DE ; replace the end-marker.
1 L1F23: POP BC ; drop the address STMT-RET.
1 L1F1A: LD BC,$0000 ; allow no overhead.
1 L1F15: LD L,$03 ; prepare 'Out of Memory'
1 L1F05: LD HL,($5C65) ; fetch STKEND
1 L1EED: POP DE ; drop the address STMT-RET
1 L1EDC: EX DE,HL ; transfer ramtop value to HL.
1 L1EDA: RST 08H ; ERROR-1
1 L1EB7: PUSH BC ; save ramtop value.
1 L1EAF: LD A,B ; test for
1 L1EAC: CALL <A href="#L1E99">L1E99</a> ; routine FIND-INT2 fetches to BC.
1 L1EA1: CALL <A href="#L1E67">L1E67</a> ; routine GO-TO puts line number in
1 L1E9F: RST 08H ; ERROR-1
1 L1E9C: JR C,<A href="#L1E9F">L1E9F</a> ; to REPORT-Bb with overflow.
1 L1E99: CALL <A href="#L2DA2">L2DA2</a> ; routine FP-TO-BC
1 L1E94: CALL <A href="#L2DD5">L2DD5</a> ; routine FP-TO-A
1 L1E8E: PUSH AF ; save the value
1 L1E85: CALL <A href="#L2DD5">L2DD5</a> ; routine FP-TO-A
1 L1E80: CALL <A href="#L1E85">L1E85</a> ; routine TWO-PARAM fetches values
1 L1E7A: CALL <A href="#L1E85">L1E85</a> ; routine TWO-PARAM fetches values
1 L1E73: LD ($5C42),HL ; save line number in NEWPPC
1 L1E67: CALL <A href="#L1E99">L1E99</a> ; routine FIND-INT2 puts operand in BC
1 L1E5F: LD HL,($5C6E) ; fetch OLDPPC line number.
1 L1E5A: LD ($5C76),BC ; place in SEED system variable.
1 L1E4F: CALL <A href="#L1E99">L1E99</a> ; routine FIND-INT2 puts parameter in BC.
1 L1E45: LD H,B ; transfer the line
1 L1E42: CALL <A href="#L1E99">L1E99</a> ; routine FIND-INT2 puts integer in BC.
1 L1E39: LD B,A ; Give BC enough space to find token.
1 L1E37: LD A,$E4 ; set token to 'DATA' and continue into
1 L1E2C: CALL <A href="#L24FB">L24FB</a> ; routine SCANNING to check syntax of
1 L1E27: CALL <A href="#L2530">L2530</a> ; routine SYNTAX-Z to check status
1 L1E1E: RST 18H ; GET-CHAR
1 L1E0A: CALL <A href="#L0077">L0077</a> ; routine TEMP-PTR1 advances updating CH_ADD
1 L1E08: RST 08H ; ERROR-1
1 L1DED: CALL <A href="#L1C1F">L1C1F</a> ; routine CLASS-01 checks variable.
1 L1DEC: RST 20H ; NEXT-CHAR
1 L1DE9: DEFB $38 ;;end-calc .
1 L1DE2: DEFB $03 ;;subtract l-v OR v-l.
1 L1DDA: RST 28H ;; FP-CALC
1 L1DD8: RST 08H ; ERROR-1
1 L1DAB: BIT 1,(IY+$37) ; test FLAGX - handling a new variable ?
1 L1DA3: PUSH BC ; save address of next line
1 L1D8B: INC HL ; increment pointer to address
1 L1D86: LD A,(HL) ; fetch current character
1 L1D84: RST 08H ; ERROR-1
1 L1D7C: RST 20H ; NEXT-CHAR
1 L1D64: PUSH BC ; save variable name.
1 L1D34: PUSH HL ; save position.
1 L1D16: RST 28H ;; FP-CALC v,l,s.
1 L1D10: CALL <A href="#L1BEE">L1BEE</a> ; routine CHECK-END
1 L1D03: CP $CD ; is there a 'STEP' ?
1 L1D00: JP <A href="#L1B29">L1B29</a> ; to STMT-L-1, if true (1) to execute command
1 L1CF0: POP BC ; drop return address - STMT-RET
1 L1CEE: RST 08H ; ERROR-1
1 L1CE6: CALL <A href="#L2530">L2530</a> ; routine SYNTAX-Z (UNSTACK-Z?)
1 L1CDE: CP $0D ; is character a carriage return ?
1 L1CDB: JP <A href="#L0605">L0605</a> ; jump way back to SAVE-ETC
1 L1CD6: CALL <A href="#L21E2">L21E2</a> ; routine CO-TEMP-2 deals with any embedded
1 L1CBE: CALL <A href="#L2530">L2530</a> ; routine SYNTAX-Z
1 L1CA5: SUB <A href="#L1AEB">L1AEB</a>-$D8 % 256 ; convert $EB to $D8 ('INK') etc.
1 L1C96: BIT 7,(IY+$01) ; test FLAGS - checking syntax only ?
1 L1C8C: CALL <A href="#L24FB">L24FB</a> ; routine SCANNING
1 L1C8A: RST 08H ; ERROR-1
1 L1C82: CALL <A href="#L24FB">L24FB</a> ; routine SCANNING
1 L1C7A: CALL <A href="#L1C82">L1C82</a> ; routine EXPT-1NUM is called for first
1 L1C79: RST 20H ; NEXT-CHAR advance past 'AT' or '('.
1 L1C6C: CALL <A href="#L28B2">L28B2</a> ; routine LOOK-VARS
1 L1C59: PUSH AF ; save A briefly
1 L1C56: LD A,($5C3B) ; initial FLAGS to A
1 L1C4E: POP BC ; drop return address SCAN-LOOP
1 L1C46: LD ($5C72),BC ; update STRLEN
1 L1C30: CALL Z,<A href="#L2996">L2996</a> ; routine STK-VAR considers a subscript/slice
1 L1C2E: RST 08H ; ERROR-1
1 L1C22: LD (IY+$37),$00 ; set FLAGX to zero
1 L1C1F: CALL <A href="#L28B2">L28B2</a> ; routine LOOK-VARS returns carry set if not
1 L1C11: POP BC ; drop address SCAN-LOOP.
1 L1C10: CP A ; reset zero flag.
1 L1C0D: CALL <A href="#L1CDE">L1CDE</a> ; routine FETCH-NUM
1 L1C01: DEFB <A href="#L1C10">L1C10</a> - $ ; 0F offset to Address: CLASS-00
1 L1BF4: RST 18H ; GET-CHAR - ignoring white space etc.
1 L1BEE: CALL <A href="#L2530">L2530</a> ; routine SYNTAX-Z
1 L1BEC: RST 08H ; ERROR-1
1 L1BD1: LD ($5C55),HL ; store pointer in system variable NXTLIN
1 L1BBF: CP $01 ; will set carry if zero.
1 L1BB3: CALL <A href="#L2530">L2530</a> ; routine SYNTAX-Z (UNSTACK-Z?)
1 L1BB2: POP BC ; drop return address STMT-RET and
1 L1BB0: RST 08H ; ERROR-1
1 L1B9E: CALL <A href="#L196E">L196E</a> ; routine LINE-ADDR gets address of line
1 L1B8A: LD HL,$FFFE ; The dummy value minus two
1 L1B7D: BIT 7,(IY+$0A) ; test NSPPC - will be set if $FF -
1 L1B7B: RST 08H ; ERROR-1
1 L1B76: CALL <A href="#L1F54">L1F54</a> ; routine BREAK-KEY is tested after every
1 L1B6F: RST 18H ; GET-CHAR
1 L1B55: LD A,(HL) ; pick up the parameter.
1 L1B52: LD HL,($5C74) ; fetch temporary address from T_ADDR
1 L1B29: CALL <A href="#L16BF">L16BF</a> ; routine SET-WORK clears workspace etc.
1 L1B28: RST 20H ; NEXT-CHAR
1 L1B17: RES 7,(IY+$01) ; update FLAGS - signal checking syntax
1 L1B14: DEFB $00 ; Class-00 - No further operands.
1 L1B10: DEFB $0A ; Class-0A - A string expression must follow.
1 L1B0A: DEFB $0A ; Class-0A - A string expression must follow.
1 L1B06: DEFB $0A ; Class-0A - A string expression must follow.
1 L1B02: DEFB $06 ; Class-06 - A numeric expression must follow.
1 L1AFC: DEFB $06 ; Class-06 - A numeric expression must follow.
1 L1AF9: DEFB $05 ; Class-05 - Variable syntax checked entirely
1 L1AF5: DEFB $06 ; Class-06 - A numeric expression must follow.
1 L1AF1: DEFB $08 ; Class-08 - Two comma-separated numeric
1 L1AF0: DEFB $07 ; Class-07 - Offset address is converted to
1 L1AEF: DEFB $07 ; Class-07 - Offset address is converted to
1 L1AEE: DEFB $07 ; Class-07 - Offset address is converted to
1 L1AED: DEFB $07 ; Class-07 - Offset address is converted to
1 L1AEC: DEFB $07 ; Class-07 - Offset address is converted to
1 L1AEB: DEFB $07 ; Class-07 - Offset address is converted to
1 L1AE7: DEFB $09 ; Class-09 - Two comma-separated numeric
1 L1AE3: DEFB $08 ; Class-08 - Two comma-separated numeric
1 L1AE2: DEFB $0B ; Class-0B - Offset address converted to tape
1 L1AE1: DEFB $0B ; Class-0B - Offset address converted to tape
1 L1AE0: DEFB $0B ; Class-0B - Offset address converted to tape
1 L1ADF: DEFB $0B ; Class-0B - Offset address converted to tape
1 L1ADC: DEFB $05 ; Class-05 - Variable syntax checked entirely
1 L1AD9: DEFB $05 ; Class-05 - Variable syntax checked entirely
1 L1AD6: DEFB $00 ; Class-00 - No further operands.
1 L1AD2: DEFB $09 ; Class-09 - Two comma-separated numeric
1 L1ACF: DEFB $03 ; Class-03 - A numeric expression may follow
1 L1ACC: DEFB $05 ; Class-05 - Variable syntax checked entirely
1 L1AC9: DEFB $05 ; Class-05 - Variable syntax checked entirely
1 L1AC5: DEFB $06 ; Class-06 - A numeric expression must follow.
1 L1AC1: DEFB $09 ; Class-09 - Two comma-separated numeric
1 L1ABE: DEFB $00 ; Class-00 - No further operands.
1 L1ABB: DEFB $03 ; Class-03 - A numeric expression may follow
1 L1AB8: DEFB $00 ; Class-00 - No further operands.
1 L1AB5: DEFB $03 ; Class-03 - A numeric expression may follow
1 L1AB1: DEFB $08 ; Class-08 - Two comma-separated numeric
1 L1AAE: DEFB $05 ; Class-05 - Variable syntax checked entirely
1 L1AAB: DEFB $03 ; Class-03 - A numeric expression may follow
1 L1AA8: DEFB $00 ; Class-00 - No further operands.
1 L1AA5: DEFB $05 ; Class-05 - Variable syntax checked entirely
1 L1AA2: DEFB $05 ; Class-05 - Variable syntax checked entirely
1 L1A9F: DEFB $05 ; Class-05 - Variable syntax checked entirely
1 L1A9C: DEFB $05 ; Class-05 - Variable syntax checked entirely
1 L1A98: DEFB $04 ; Class-04 - A single character variable must
1 L1A90: DEFB $04 ; Class-04 - A single character variable must
1 L1A8D: DEFB $00 ; Class-00 - No further operands.
1 L1A8A: DEFB $00 ; Class-00 - No further operands.
1 L1A86: DEFB $06 ; Class-06 - A numeric expression must follow.
1 L1A81: DEFB $06 ; Class-06 - A numeric expression must follow.
1 L1A7D: DEFB $06 ; Class-06 - A numeric expression must follow.
1 L1A7A: DEFB $01 ; Class-01 - A variable is required.
1 L1A48: DEFB <A href="#L1AF9">L1AF9</a> - $ ; B1 offset to Address: P-DEF-FN
1 L1A42: CALL <A href="#L15EF">L15EF</a> ; routine OUT-CODE for final digit.
1 L1A30: LD BC,$FC18 ; value -1000
1 L1A28: PUSH DE ; save flags
1 L1A1B: PUSH DE ; save the
1 L1A15: JP C,<A href="#L1C8A">L1C8A</a> ; to REPORT-C 'Nonsense in BASIC' if over.
1 L19FB: LD HL,($5C59) ; load HL from system variable E_LINE.
1 L19E8: PUSH BC ;
1 L19E5: CALL <A href="#L19DD">L19DD</a> ; routine DIFFER immediately above
1 L19DD: AND A ; prepare for true subtraction.
1 L19DB: ADD HL,BC ; add the length to give address of next
1 L19D6: INC HL ; increment to address the length low byte.
1 L19D5: INC HL ; increment pointer to low byte of line no.
1 L19CE: RLA ; test if character inverted. carry will also
1 L19C7: LD BC,$0005 ; set BC to 5 for floating point number
1 L19B8: PUSH HL ; save the pointer address.
1 L19B1: CP $0D ; end of line ?
1 L19AD: BIT 0,C ; is it in quotes
1 L19A5: CP $3A ; is it ':'
1 L199A: CALL <A href="#L18B6">L18B6</a> ; routine NUMBER skips if number marker
1 L1998: INC HL ; next address
1 L1990: DEC D ; decrease statement count
1 L198B: LD ($5C5D),HL ; save HL in CH_ADD
1 L1988: INC HL ;
1 L1980: LD A,(HL) ; Load the high byte of line number and
1 L1974: POP BC ; restore the line number to BC
1 L196E: PUSH HL ; save line number in HL register
1 L196C: RST 10H ; PRINT-A vectors the character to
1 L1968: SET 2,(IY+$01) ; update FLAGS - signal L mode if the cursor
1 L195A: CP $22 ; is it quote character '"' ?
1 L1937: CALL <A href="#L2D1B">L2D1B</a> ; routine NUMERIC tests if it is a digit ?
1 L192B: ADD HL,BC ; add negative number to HL.
1 L192A: XOR A ; initialize digit to 0
1 L1925: LD A,E ; will be space if OUT-CODE not yet called.
1 L191C: BIT 5,(IY+$37) ; test FLAGX - input mode ?
1 L190F: LD E,(HL) ; fetch low byte
1 L1909: PUSH DE ; save address pointer but OK as OUT-FLASH
1 L18F3: LD HL,$5C3B ; Address FLAGS
1 L18E1: LD HL,($5C5B) ; fetch K_CUR the current cursor address
1 L18C1: EXX ; switch in alternate set
1 L18B6: CP $0E ; character fourteen ?
1 L18B4: POP DE ; bring back the flag E, zero if current
1 L18A1: CALL <A href="#L18E1">L18E1</a> ; routine OUT-CURS will print the cursor if
1 L1894: LD HL,($5C5F) ; fetch X_PTR - possibly the error pointer
1 L1881: PUSH DE ; save flag E for a return value.
1 L187D: SET 0,(IY+$01) ; update FLAGS - suppress leading space.
1 L1865: LD (IY+$2D),E ; save flag in BREG which is spare.
1 L1855: LD BC,($5C49) ; fetch E_PPC the current line which may be
1 L1835: CALL <A href="#L1855">L1855</a> ; routine OUT-LINE outputs a BASIC line
1 L1833: LD E,$01 ; signal current line not yet printed
1 L1822: CALL <A href="#L1BEE">L1BEE</a> ; routine CHECK-END quits if syntax OK >>>
1 L181F: CALL <A href="#L1CDE">L1CDE</a> ; routine FETCH-NUM checks if a number
1 L181A: CALL <A href="#L1CE6">L1CE6</a> ; routine USE-ZERO
1 L1814: RST 20H ; NEXT-CHAR
1 L17FB: LD (IY+$02),$00 ; the TV_FLAG is initialized with bit 0 reset
1 L17F9: LD A,$02 ; default is stream 2 - the upper screen.
1 L17F5: LD A,$03 ; the usual stream for ZX Printer
1 L17ED: CALL <A href="#L1833">L1833</a> ; routine LIST-ALL >>>
1 L17E4: LD HL,($5C6C) ; fetch S_TOP line number to HL.
1 L17E1: LD ($5C6C),HL ; make S_TOP the same as E_PPC.
1 L17CE: PUSH BC ; save the result.
1 L1795: LD ($5C3F),SP ; save stack pointer in LIST_SP
1 L1793: JR <A href="#L1725">L1725</a> ; to REPORT-Ob
1 L178B: DEC BC ; the stored length of 'K','S','P' or
1 L1789: LD E,$10 ; 16d is offset to 2nd byte of channel 'P'
1 L1785: LD E,$06 ; 06 is offset to 2nd byte of channel 'S'
1 L1781: LD E,$01 ; 01 is offset to second byte of channel 'K'.
1 L177A: DEFB 'K', <A href="#L1781">L1781</a>-$-1 ; $06 offset to OPEN-K
1 L1767: PUSH BC ; save the length of the string.
1 L1765: RST 08H ; ERROR-1
1 L175D: PUSH HL ; * save the STRMS data entry pointer.
1 L1756: CALL <A href="#L175D">L175D</a> ; routine OPEN-2 opens the stream.
1 L1736: RST 28H ;; FP-CALC ;s,c.
1 L1727: ADD A,$03 ; add the offset for 3 system streams.
1 L1725: RST 08H ; ERROR-1
1 L171E: CALL <A href="#L1E94">L1E94</a> ; routine FIND-INT1 fetches parameter to A
1 L171C: POP HL ; * now just restore the stream data pointer
1 L1716: DEFB 'K', <A href="#L171C">L171C</a>-$-1 ; offset 5 to CLOSE-STR
1 L1708: INC HL ; to address channel's letter
1 L1701: PUSH HL ; * save address of stream data pointer
1 L16FC: EX DE,HL ; address of stream to HL.
1 L16E5: CALL <A href="#L171E">L171E</a> ; routine STR-DATA fetches parameter
1 L16DC: LD A,(HL) ; fetch the first byte of pair
1 L16DB: INC HL ; address the next pair of values.
1 L16D4: LD DE,($5C59) ; fetch start of edit line from E_LINE.
1 L16C5: LD HL,($5C63) ; fetch STKBOT value
1 L16BF: LD HL,($5C61) ; fetch WORKSP value
1 L16B0: LD HL,($5C59) ; fetch E_LINE
1 L169E: LD HL,($5C63) ; STKBOT first location of calculator stack
1 L1695: LD A,(HL) ; fetch the high byte - max $2F
1 L1691: EX DE,HL ; fetch the previous line to HL and set
1 L168F: DEFB $00, $00 ; dummy line number used for direct commands
1 L167F: INC HL ; address next system variable.
1 L166B: LD E,(HL) ; fetch the low byte of the system variable.
1 L1664: PUSH AF ; preserve accumulator.
1 L1655: PUSH HL ; save the address pointer.
1 L1652: LD BC,$0001 ; create space for a single character.
1 L164D: SET 1,(IY+$01) ; update FLAGS - signal printer in use
1 L1646: RES 1,(IY+$01) ; update FLAGS - signal printer not in use
1 L1642: RES 0,(IY+$02) ; TV_FLAG - signal main screen in use
1 L1634: SET 0,(IY+$02) ; update TV_FLAG - signal lower screen in use
1 L162D: DEFB 'K', <A href="#L1634">L1634</a>-$-1 ; offset $06 to CHAN-K
1 L162C: JP (HL) ; jump to the routine
1 L1615: LD ($5C51),HL ; set CURCHL system variable to the
1 L1610: DEC DE ; reduce offset so it points to the channel.
1 L160E: RST 08H ; ERROR-1
1 L1601: ADD A,A ; double the stream ($FF will become $FE etc.)
1 L15F7: LD E,(HL) ; put the low byte in E.
1 L15F2: EXX ; switch in alternate set
1 L15EF: LD E,$30 ; add 48 decimal to give the ASCII character
1 L15E6: EXX ; switch in alternate set.
1 L15E4: RST 08H ; ERROR-1
1 L15DE: CALL <A href="#L15E6">L15E6</a> ; routine INPUT-AD is called.
1 L15D4: BIT 5,(IY+$02) ; test TV_FLAG - clear lower screen ?
1 L15C6: DEFB $01, $00 ; stream $FD offset to channel 'K'
1 L15C4: RST 08H ; ERROR-1
1 L15AF: DEFW <A href="#L09F4">L09F4</a> ; PRINT-OUT
1 L15AB: POP AF ; drop the address of Report G
1 L157D: POP BC ; retrieve the length of the new line.
1 L155D: LD ($5C49),BC ; set E_PPC to extracted line number.
1 L1555: LD A,$10 ; i.e. 'G' -$30 -$07
1 L1539: DEFB $7F ; copyright
1 L1537: DEFB ',',' '+$80 ; used in report line.
1 L1391: DEFB $80
1 L1386: LD (IY+$0A),$FF ; update NSPPC - signal 'no jump'.
1 L1384: LDDR ; copy PPC to OLDPPC and SUBPPC to OSPCC
1 L1376: LD BC,$0003 ; prepare to copy 3 system variables to
1 L1373: INC (IY+$0D) ; increment SUBPPC to next statement.
1 L133C: CALL <A href="#L15EF">L15EF</a> ; call routine OUT-CODE to print the code.
1 L1313: PUSH AF ; save the error number.
1 L1303: HALT ; wait for interrupt the only routine that can
1 L12CF: LD HL,($5C59) ; fetch the edit line address from E_LINE.
1 L12AC: LD A,$00 ; select channel 'K' the keyboard
1 L12A9: CALL <A href="#L16B0">L16B0</a> ; routine SET-MIN clears work areas.
1 L12A2: LD (IY+$31),$02 ; set DF_SZ lower screen display file size to
1 L1219: LD ($5CB2),HL ; set system variable RAMTOP to HL.
1 L11EF: DEC HL ; step back to last valid location.
1 L11E2: AND A ; Clear carry - prepare to subtract.
1 L11DC: LD (HL),$02 ; Load memory with $02 - red ink on black paper.
1 L11DA: LD H,D ; Transfer the top value to the HL register
1 L11CB: LD B,A ; Save the flag to control later branching.
1 L11B7: DI ; Disable Interrupts - machine stack will be
1 L11A7: LD A,(HL) ; fetch character
1 L1195: LD DE,($5C59) ; fetch E_LINE to DE
1 L1190: LD HL,($5C61) ; fetch WORKSP to HL.
1 L117E: POP HL ; restore the old value of ERR_SP.
1 L117C: POP DE ; fetch new line/column.
1 L1167: LD D,$00 ; prepare to moan.
1 L115E: LD A,$20 ; prepare a space.
1 L1150: LD A,($5C8B) ; fetch SPOSNL_hi is current line
1 L111D: CALL <A href="#L0D4D">L0D4D</a> ; routine TEMPS sets temporary attributes.
1 L111B: SCF ; set carry flag to show a key has been found
1 L1113: LD HL,($5C4F) ; address start of CHANNELS area using CHANS
1 L110D: LD A,($5C0D) ; pick up the parameter stored in KDATA.
1 L1105: LD (IY-$2D),C ; put the colour (0-7)/state(0/1) in KDATA
1 L10FA: LD B,A ; make a copy of character.
1 L10F4: SET 3,(IY+$02) ; update TV_FLAG - show key state has changed
1 L10E6: CP $0E ; compare with chr 14d
1 L10DB: JR NZ,<A href="#L10E6">L10E6</a> ; forward to KEY-MODE if not 06 (capslock)
1 L10A8: BIT 3,(IY+$02) ; test TV_FLAG - has a key been pressed in
1 L1097: PUSH HL ; preserve HL
1 L107F: BIT 4,(IY+$30) ; test FLAGS2 - is K channel in use ?
1 L107C: JP <A href="#L0F81">L0F81</a> ; jump back to ADD-CHAR
1 L1076: BIT 7,(IY+$37) ; test FLAGX - is this INPUT LINE ?
1 L106E: CALL <A href="#L1795">L1795</a> ; routine AUTO-LIST lists to upper screen
1 L1059: BIT 5,(IY+$37) ; test FLAGX - input mode ?
1 L1051: AND A ; prepare for true subtraction
1 L103E: LD H,D ; transfer DE - leftmost pointer
1 L1031: SCF ; carry flag must be set to call the nested
1 L1026: POP HL ; the previous value of ERR_SP
1 L1024: POP HL ; discard address ED-LOOP
1 L101E: CALL <A href="#L15D4">L15D4</a> ; routine WAIT-KEY to ignore keystroke.
1 L1015: CALL <A href="#L1031">L1031</a> ; routine ED-EDGE moves cursor to left.
1 L1011: LD ($5C5B),HL ; update K_CUR system variable
1 L100C: LD A,(HL) ; fetch addressed character.
1 L1007: CALL <A href="#L1031">L1031</a> ; routine ED-EDGE moves left if possible
1 L1001: LD (IY+$00),$10 ; set ERR_NR to 'STOP in INPUT' code
1 L0FF3: BIT 5,(IY+$37) ; test FLAGX - Input Mode ?
1 L0FA9: LD HL,($5C49) ; fetch E_PPC the last line number entered.
1 L0FA0: DEFB <A href="#L0FA9">L0FA9</a> - $ ; 07d offset $09 to Address: ED-EDIT
1 L0F92: LD E,A ; character to E.
1 L0F8B: LD (DE),A ; load current character to last new location.
1 L0F81: RES 0,(IY+$07) ; set MODE to 'L'
1 L0F6C: CALL <A href="#L15D4">L15D4</a> ; routine WAIT-KEY for control.
1 L0F38: CALL <A href="#L15D4">L15D4</a> ; routine WAIT-KEY gets key possibly
1 L0F30: LD HL,<A href="#L107F">L107F</a> ; address: ED-ERROR
1 L0F2C: LD HL,($5C3D) ; fetch ERR_SP
1 L0F1E: IN A,($FB) ; read the port.
1 L0F18: RL D ; prepare mask to receive bit.
1 L0F14: LD E,(HL) ; fetch a byte from line.
1 L0F0C: IN A,($FB) ; test now to see if
1 L0F0A: RST 08H ; ERROR-1
1 L0EFD: CALL <A href="#L1F54">L1F54</a> ; call BREAK-KEY to read keyboard immediately.
1 L0EF4: LD A,B ; fetch the counter 1-8 or 1-176
1 L0EE7: LD (HL),A ; set addressed location to zero.
1 L0EDF: LD HL,$5B00 ; the location of the buffer.
1 L0EDA: LD A,$04 ; output value 4 to port
1 L0ED3: PUSH BC ; save counter.
1 L0ECD: DI ; disable interrupts
1 L0EC9: DJNZ <A href="#L0EB2">L0EB2</a> ; back to COPY-1 for all lines.
1 L0EB2: PUSH HL ; save the screen address.
1 L0EAF: LD HL,$4000 ; address start of the display file.
1 L0EAC: DI ; disable interrupts as this is time-critical.
1 L0E9B: LD A,$18 ; reverse the line number
1 L0E88: LD A,H ; fetch H to A - $48, $50, or $58.
1 L0E80: LD (HL),A ; put attribute in first byte.
1 L0E4D: AND $07 ; mask 0-7 to consider thirds at a time
1 L0E4A: PUSH BC ; save pixel line count
1 L0E44: PUSH BC ; save line count
1 L0E19: EX DE,HL ; save source in DE.
1 L0E0D: EX DE,HL ; copy HL to DE.
1 L0E05: PUSH BC ; save counters.
1 L0E00: CALL <A href="#L0E9B">L0E9B</a> ; routine CL-ADDR gets screen address in HL.
1 L0DFE: LD B,$17 ; scroll 23 lines, after 'scroll?'.
1 L0DF4: LD A,$21 ; the column $01-$21 is reversed
1 L0DEE: PUSH BC ; save the line/column.
1 L0DD9: LD HL,$5B00 ; the base address of printer buffer
1 L0DAF: LD HL,$0000 ; Initialize plot coordinates.
1 L0DA0: LD (HL),E ; Insert the output address on the first pass
1 L0D94: LD A,$FD ; select system channel 'K'
1 L0D8E: DJNZ <A href="#L0D87">L0D87</a> ; decrease B counter and back to CLS-1
1 L0D89: DEC HL ; decrease attribute address.
1 L0D87: LD C,$20 ; set counter to 32 character cells per line
1 L0D6E: LD HL,$5C3C ; address System Variable TV_FLAG.
1 L0D6B: CALL <A href="#L0DAF">L0DAF</a> ; Routine CL-ALL clears the entire display and
1 L0D65: XOR (HL) ;
1 L0D5B: LD ($5C8F),HL ; transfer values to ATTR_T and MASK_T
1 L0D4D: XOR A ; clear the accumulator
1 L0D2D: CALL <A href="#L0E00">L0E00</a> ; routine CL-SCROLL scrolls B lines
1 L0D1C: PUSH AF ; save scroll number.
1 L0D02: CP $02 ; is line number less than 2 ?
1 L0D00: RST 08H ; ERROR-1
1 L0CF8: DEFB $80 ; initial step-over byte.
1 L0CF0: LD (DE),A ; transfer
1 L0CD2: CALL <A href="#L0DFE">L0DFE</a> ; routine CL-SC-ALL to scroll whole display
1 L0C88: DEC (IY+$52) ; decrease SCR_CT
1 L0C86: RST 08H ; ERROR-1
1 L0C55: BIT 1,(IY+$01) ; test FLAGS - is printer in use ?
1 L0C44: BIT 7,(HL) ; is character inverted ?
1 L0C41: PUSH AF ; save the message/token number
1 L0C3B: PUSH DE ; Save DE value.
1 L0C35: LD A,D ; The trailing space flag (zero if an error msg)
1 L0C22: LD A,(DE) ; Fetch character from the table.
1 L0C14: CALL <A href="#L0C41">L0C41</a> ; routine PO-SEARCH will set carry for
1 L0C10: LD DE,<A href="#L0095">L0095</a> ; address: TKN-TABLE
1 L0C0A: PUSH HL ; put hi-byte zero on stack to suppress
1 L0C08: LD (HL),A ; save the new attribute.
1 L0BFA: BIT 4,(IY+$57) ; test P_FLAG - Is this INK 9 ??
1 L0BDB: LD A,H ; fetch high byte $40 - $57
1 L0BD3: EX AF,AF' ; save the flag
1 L0BC1: INC HL ; address next character byte
1 L0BB7: EX AF,AF' ; save printer/screen flag
1 L0BB6: EX DE,HL ; now HL=source, DE=destination
1 L0BA4: RRA ; skip bit 1 of P_FLAG
1 L0B93: CP C ; this test is really for screen - new line ?
1 L0B7F: LD A,C ; column to A
1 L0B76: LD H,$00 ; set high byte to 0
1 L0B6A: EX DE,HL ; transfer destination address to DE
1 L0B65: PUSH BC ; save print position
1 L0B5F: CALL <A href="#L0C10">L0C10</a> ; routine PO-TOKENS prints tokens
1 L0B52: SUB $A5 ; the 'RND' character
1 L0B4C: LD (HL),A ; store bit patterns in temporary buffer
1 L0B3E: RR B ; rotate bit 0/2 to carry
1 L0B38: LD HL,$5C92 ; address MEM-0 - a temporary buffer in
1 L0B24: CP $80 ; ASCII ?
1 L0B1D: LD C,(IY+$45) ; Fetch column from P_POSN.
1 L0B03: BIT 1,(IY+$01) ; Test FLAGS - is printer in use ?
1 L0AFC: LD (IY+$45),C ; Update P_POSN column position printer
1 L0AF0: LD ($5C8A),BC ; Update SPOSNL line/column lower screen
1 L0ADC: BIT 1,(IY+$01) ; Test FLAGS - is printer in use ?
1 L0AD9: CALL <A href="#L0B24">L0B24</a> ; routine PO-ANY
1 L0AD0: LD A,$20 ; space character.
1 L0AC3: CALL <A href="#L0B03">L0B03</a> ; routine PO-FETCH, HL-addr, BC=line/column.
1 L0AC2: LD A,H ; transfer parameter to A
1 L0ABF: JP <A href="#L0DD9">L0DD9</a> ; print position is valid so exit via CL-SET
1 L0AAC: JP C,<A href="#L1E9F">L1E9F</a> ; to REPORT-B if higher than 22 decimal
1 L0A87: LD DE,<A href="#L09F4">L09F4</a> ; Address: PRINT-OUT
1 L0A80: LD HL,($5C51) ; use CURCHL to find current output channel.
1 L0A7D: LD ($5C0E),A ; store control code in TVDATA-lo
1 L0A7A: LD DE,<A href="#L0A87">L0A87</a> ; address: PO-CONT will be next output routine
1 L0A75: LD DE,<A href="#L0A6D">L0A6D</a> ; address: PO-TV-2 will be next output routine
1 L0A6D: LD DE,<A href="#L0A87">L0A87</a> ; address: PO-CONT will be next output routine
1 L0A69: LD A,$3F ; prepare the character '?'.
1 L0A5F: CALL <A href="#L0B03">L0B03</a> ; routine PO-FETCH - seems unnecessary.
1 L0A4F: BIT 1,(IY+$01) ; test FLAGS - is printer in use ?
1 L0A3D: LD A,($5C91) ; fetch P_FLAG value
1 L0A3A: JP <A href="#L0DD9">L0DD9</a> ; to CL-SET and PO-STORE to save new
1 L0A38: LD C,$21 ; the leftmost column position.
1 L0A23: INC C ; move left one column.
1 L0A11: DEFB <A href="#L0A5F">L0A5F</a> - $ ; 06d offset $4E to Address: PO-COMMA
1 L09F4: CALL <A href="#L0B03">L0B03</a> ; routine PO-FETCH fetches print position
1 L09C0: DEFB '.'+$80
1 L09A1: DEFB $80
1 L0991: HALT ; wait for interrupt
1 L0970: PUSH HL ; save start of data
1 L0958: INC HL ; address next?
1 L0955: CALL <A href="#L1655">L1655</a> ; routine MAKE-ROOM creates room for variable.
1 L093E: EX AF,AF' ; save or re-save flags.
1 L092C: JR NZ,<A href="#L093E">L093E</a> ; forward to ME-ENT-1 for insertion only.
1 L0923: POP DE ; pop workspace pointer.
1 L0921: LD A,$FF ; indicate a replacement.
1 L091E: POP HL ; restore the prog/vars pointer.
1 L0912: INC HL ; address next character in vars area.
1 L0909: AND $E0 ; keep bits 11100000
1 L0901: PUSH BC ; save character in C.
1 L08F9: LD A,(HL) ; fetch first byte.
1 L08F0: LD A,(HL) ; fetch first byte of workspace variable.
1 L08EB: CALL <A href="#L092C">L092C</a> ; routine ME-ENTER enters the line
1 L08DF: DEC DE ; point to start of
1 L08D7: LD A,(DE) ; fetch high byte from program area.
1 L08D2: LD A,(HL) ; fetch next byte from workspace.
1 L08B6: LD C,(IX+$0B) ; fetch length
1 L08AD: POP DE ; ** pop the length
1 L0873: EX DE,HL ; transfer dest to DE.
1 L084C: LD HL,($5C59) ; address E_LINE
1 L082E: POP HL ; pop destination
1 L0825: LD DE,$0005 ; allow overhead of five bytes.
1 L0819: LD L,(IX-$06) ; fetch length from
1 L0808: LD E,(IX+$0B) ; fetch length of found data block
1 L0806: RST 08H ; ERROR-1
1 L0802: CALL <A href="#L0556">L0556</a> ; routine LD-BYTES
1 L0800: LD A,$FF ; signal data block to be loaded
1 L07F4: PUSH HL ; push pointer to start of data block.
1 L07E9: POP HL ; pop pointer to data
1 L07CB: PUSH HL ; save pointer to data.
1 L07AD: RST 10H ; PRINT-A prints character
1 L07A6: INC DE ; address next input character
1 L078A: CP $04 ; check if type in acceptable range 0 - 3.
1 L0767: PUSH IX ; save IX
1 L075A: LD A,($5C74) ; fetch command from T_ADDR
1 L073A: LD (IX+$00),$00 ; place type zero - program in descriptor.
1 L0723: LD A,($5C74) ; fetch command from T_ADDR
1 L0716: CP $CA ; is character the token 'LINE' ?
1 L0710: LD (IX+$00),$03 ; place type 3 - code in descriptor.
1 L06F9: CALL <A href="#L1BEE">L1BEE</a> ; routine CHECK-END errors with extraneous
1 L06F5: RST 20H ; NEXT-CHAR advances character address.
1 L06F0: CALL <A href="#L1CE6">L1CE6</a> ; routine USE-ZERO stacks zero for length.
1 L06E1: CALL <A href="#L1C82">L1C82</a> ; routine EXPT-1NUM checks for numeric
1 L06C3: CP $AF ; is character the token 'CODE' ?
1 L06A0: CP $AA ; is character the token 'SCREEN$' ?
1 L0692: EX DE,HL ; save var pointer in DE
1 L068F: LD (IX+$00),A ; place type 0, 1 or 2 in descriptor.
1 L0685: LD (IX+$0E),C ; place character array name in header.
1 L0672: JP NZ,<A href="#L1C8A">L1C8A</a> ; to REPORT-C if not an array variable.
1 L0670: RST 08H ; ERROR-1
1 L0652: RST 18H ; GET-CHAR
1 L064B: PUSH IX ; push start of file descriptor.
1 L0644: LD A,B ; test length of filename
1 L0642: RST 08H ; ERROR-1
1 L0629: LD (DE),A ; set workspace location to space.
1 L0621: RST 30H ; BC-SPACES creates 17/34 bytes in workspace.
1 L0609: SUB <A href="#L1ADF">L1ADF</a> + 1 % 256 ; subtract the known offset.
1 L0605: POP AF ; discard address STMT-RET.
1 L05ED: INC B ; increment the time-out counter.
1 L05E9: DEC A ; decrement counter
1 L05E7: LD A,$16 ; a delay value of twenty two.
1 L05E3: CALL <A href="#L05E7">L05E7</a> ; call routine LD-EDGE-1 below.
1 L05CA: CALL <A href="#L05E3">L05E3</a> ; routine LD-EDGE-2 increments B relative to
1 L05C8: LD L,$01 ; initialize as %00000001
1 L05C4: DEC DE ; decrement length.
1 L05C2: INC IX ; increment byte pointer.
1 L05BD: LD A,(IX+$00) ; fetch byte from memory.
1 L05B3: RL C ; preserve carry (verify) flag in long-term
1 L05A9: EX AF,AF' ; restore entry flags and type in A.
1 L058F: LD B,$C9 ; initial timing value in B.
1 L0580: LD B,$9C ; set timing value.
1 L0574: DJNZ <A href="#L0574">L0574</a> ; self loop to LD-WAIT (for 256 times)
1 L056C: CALL <A href="#L05E7">L05E7</a> ; routine LD-EDGE-1
1 L056B: RET NZ ; return if at any time space is pressed.
1 L0556: INC D ; reset the zero flag without disturbing carry.
1 L0554: POP AF ; restore the accumulator.
1 L0552: RST 08H ; ERROR-1
1 L053F: PUSH AF ; preserve accumulator throughout.
1 L053C: DJNZ <A href="#L053C">L053C</a> ; self loop to SA-DELAY
1 L0525: RL L ; rotate left through carry
1 L051C: OUT ($FE),A ; blue and mic on OR yellow and mic off.
1 L051A: DJNZ <A href="#L051A">L051A</a> ; self loop to SA-SET
1 L0514: DJNZ <A href="#L0514">L0514</a> ; self loop for delay to SA-BIT-1
1 L0511: LD A,C ; fetch 'mic on and yellow' which is
1 L050E: LD L,H ; transfer the running parity byte to L and
1 L0507: LD H,A ; put parity byte in H.
1 L0505: LD A,H ; fetch parity byte.
1 L04FE: LD A,D ; fetch high byte
1 L04F2: DJNZ <A href="#L04F2">L04F2</a> ; self loop to SA-SYNC-2
1 L04EA: DJNZ <A href="#L04EA">L04EA</a> ; self loop to SA-SYNC-1
1 L04D8: DJNZ <A href="#L04D8">L04D8</a> ; self loop to SA-LEADER for delay.
1 L04D0: EX AF,AF' ; save flag
1 L04C2: LD HL,<A href="#L053F">L053F</a> ; address: SA/LD-RET
1 L04AA: CALL <A href="#L24FB">L24FB</a> ; routine SCANNING to evaluate expression.
1 L046E: DEFB $89, $02, $D0, $12, $86; 261.625565290 C
1 L046C: RST 08H ; ERROR-1
1 L0427: INC B ; increment octave
1 L0425: LD B,$FA ; 6 octaves below middle C
1 L03F8: RST 28H ;; FP-CALC
1 L03F6: EI ; Enable Interrupts
1 L03F2: LD C,L ;(4) ; C = medium part of tone period
1 L03D6: DEC C ;(4) ; timing loop for duration of
1 L03D4: INC B ;(4) ;
1 L03D3: NOP ;(4) ;
1 L03D2: NOP ;(4) ;
1 L03D1: NOP ;(4) ; optionally executed NOPs for small
1 L03B5: DI ; Disable Interrupts so they don't disturb timing
1 L03B2: LD A,$40 ; substitute ASCII '@'
1 L039D: INC B ; return with digit codes if neither
1 L0389: LD HL,<A href="#L0260">L0260</a>-$30 ; $0230 base address of CTL-CODES
1 L0382: SUB $36 ; reduce to 02 and 03 bright codes
1 L0367: CP $30 ; is it '0' or higher ?
1 L0364: ADD A,$A5 ; add offset to main code so that 'A'
1 L034F: LD HL,<A href="#L026A">L026A</a>-$41 ; prepare base of sym-codes
1 L034A: LD D,$00 ; prepare to index.
1 L0341: LD HL,<A href="#L022C">L022C</a>-$41 ; base address of E-UNSHIFT L022c.
1 L0333: LD A,E ; pick up the stored main key
1 L032C: LD HL,<A href="#L0205">L0205</a> ; address: MAIN-KEYS
1 L031E: LD B,D ; load most significant key to B
1 L0310: INC HL ; increment the map pointer to second location.
1 L0308: LD ($5C08),A ; update LASTK system variable.
1 L02F1: LD E,A ; store key in E
1 L02D1: LD A,L ; make a copy of the low address byte.
1 L02C6: BIT 7,(HL) ; is it free ? (i.e. $FF)
1 L02BF: CALL <A href="#L028E">L028E</a> ; routine KEY-SCAN
1 L02AB: DEC L ; cycles 2F>2E>2D>2C>2B>2A>29>28 for
1 L02A1: SUB $08 ; subtract 8 from the key value
1 L029F: INC D ; now test the key buffer
1 L0296: IN A,(C) ; read the port to A - bits will be reset
1 L028E: LD L,$2F ; initial key value
1 L0284: DEFB $D0 ; FORMAT
1 L026A: DEFB $E2 ; STOP
1 L0260: DEFB $0C ; DELETE
1 L0246: DEFB $7E ; ~
1 L022C: DEFB $E3 ; READ
1 L0205: DEFB $42 ; B
1 L0095: DEFB '?'+$80
1 L0090: SCF ; set the carry flag
1 L007D: CP $21 ; test if higher than space.
1 L0078: LD ($5C5D),HL ; update CH_ADD with character address.
1 L0077: INC HL ; increase the character address by one.
1 L0074: LD HL,($5C5D) ; fetch address from CH_ADD.
1 L0070: POP HL ; restore the
1 L0066: PUSH AF ; save the
1 L0055: LD (IY+$00),L ; Store it in the system variable ERR_NR.
1 L0053: POP HL ; drop the return address - the location
1 L0048: PUSH BC ; Save the other main registers.
1 L0038: PUSH AF ; Save the registers that will be used but not
1 L0030: PUSH BC ; Save number of spaces.
1 L0028: JP <A href="#L335B">L335B</a> ; jump forward to the CALCULATE routine.
1 L0020: CALL <A href="#L0074">L0074</a> ; routine CH-ADD+1 fetches the next immediate
1 L001C: CALL <A href="#L007D">L007D</a> ; routine SKIP-OVER tests if the character is
1 L0018: LD HL,($5C5D) ; fetch the address from CH_ADD.
1 L0010: JP <A href="#L15F2">L15F2</a> ; Jump forward to continue at PRINT-A-2.
1 L0008: LD HL,($5C5D) ; Fetch the character address from CH_ADD.
1 L0000: DI ; Disable Interrupts.
1 Assembly Listing of the Operating System of the Sinclair ZX Spectrum.
1 <font face = "Courier"> </font>
1 <a name="L3D00"></a>;; <b>char-set</b>
1 <a name="L386E"></a>;; <b>spare</b>
1 <a name="L386C"></a>;; <b>LAST</b>
1 <a name="L386A"></a>;; <b>ONE</b>
1 <a name="L385D"></a>;; <b>XIS0</b>
1 <a name="L3851"></a>;; <b>to-power</b>
1 <a name="L384A"></a>;; <b>sqr</b>
1 <a name="L3843"></a>;; <b>acs</b>
1 <a name="L3833"></a>;; <b>asn</b>
1 <a name="L37FA"></a>;; <b>CASES</b>
1 <a name="L37F8"></a>;; <b>SMALL</b>
1 <a name="L37E2"></a>;; <b>atn</b>
1 <a name="L37DA"></a>;; <b>tan</b>
1 <a name="L37B7"></a>;; <b>C-ENT</b>
1 <a name="L37B5"></a>;; <b>sin</b>
1 <a name="L37AA"></a>;; <b>cos</b>
1 <a name="L37A8"></a>;; <b>YNEG</b>
1 <a name="L37A1"></a>;; <b>ZPLUS</b>
1 <a name="L3783"></a>;; <b>get-argt</b>
1 <a name="L373D"></a>;; <b>GRE.8</b>
1 <a name="L371C"></a>;; <b>VALID</b>
1 <a name="L371A"></a>;; <b>REPORT-Ab</b>
1 <a name="L3713"></a>;; <b>ln</b>
1 <a name="L370E"></a>;; <b>RSLT-ZERO</b>
1 <a name="L370C"></a>;; <b>RESULT-OK</b>
1 <a name="L3705"></a>;; <b>N-NEGTV</b>
1 <a name="L3703"></a>;; <b>REPORT-6b</b>
1 <a name="L36C4"></a>;; <b>exp</b>
1 <a name="L36C4"></a>;; <b>EXP</b>
1 <a name="L36C2"></a>;; <b>EXIT</b>
1 <a name="L36B7"></a>;; <b>X-NEG</b>
1 <a name="L36AF"></a>;; <b>int</b>
1 <a name="L36A0"></a>;; <b>n-mod-m</b>
1 <a name="L369B"></a>;; <b>end-calc</b>
1 <a name="L368F"></a>;; <b>jump-true</b>
1 <a name="L3687"></a>;; <b>JUMP-2</b>
1 <a name="L3686"></a>;; <b>jump</b>
1 <a name="L3686"></a>;; <b>JUMP</b>
1 <a name="L367A"></a>;; <b>dec-jr-nz</b>
1 <a name="L3674"></a>;; <b>len</b>
1 <a name="L3671"></a>;; <b>STK-CODE</b>
1 <a name="L3669"></a>;; <b>code</b>
1 <a name="L365F"></a>;; <b>R-I-STORE</b>
1 <a name="L3645"></a>;; <b>read-in</b>
1 <a name="L361F"></a>;; <b>str$</b>
1 <a name="L360C"></a>;; <b>V-RPORT-C</b>
1 <a name="L35DE"></a>;; <b>val</b>
1 <a name="L35DE"></a>;; <b>val$</b>
1 <a name="L35DC"></a>;; <b>REPORT-Bd</b>
1 <a name="L35C9"></a>;; <b>chrs</b>
1 <a name="L35BF"></a>;; <b>STK-PNTRS</b>
1 <a name="L35B7"></a>;; <b>OTHER-STR</b>
1 <a name="L359C"></a>;; <b>strs-add</b>
1 <a name="L358C"></a>;; <b>END-TESTS</b>
1 <a name="L3588"></a>;; <b>STR-TEST</b>
1 <a name="L3585"></a>;; <b>FRST-LESS</b>
1 <a name="L3575"></a>;; <b>SEC-PLUS</b>
1 <a name="L3572"></a>;; <b>BOTH-NULL</b>
1 <a name="L356B"></a>;; <b>SECND-LOW</b>
1 <a name="L3564"></a>;; <b>BYTE-COMP</b>
1 <a name="L3559"></a>;; <b>STRINGS</b>
1 <a name="L354E"></a>;; <b>NU-OR-STR</b>
1 <a name="L3543"></a>;; <b>EX-OR-NOT</b>
1 <a name="L353B"></a>;; <b>no-l-eql,etc.</b>
1 <a name="L351B"></a>;; <b>or</b>
1 <a name="L350B"></a>;; <b>FP-0/1</b>
1 <a name="L3507"></a>;; <b>SIGN-TO-C</b>
1 <a name="L3506"></a>;; <b>less-0</b>
1 <a name="L3501"></a>;; <b>not</b>
1 <a name="L3501"></a>;; <b>NOT</b>
1 <a name="L34F9"></a>;; <b>greater-0</b>
1 <a name="L34F9"></a>;; <b>GREATER-0</b>
1 <a name="L34E9"></a>;; <b>TEST-ZERO</b>
1 <a name="L34E7"></a>;; <b>REPORT-A</b>
1 <a name="L34E4"></a>;; <b>USR-STACK</b>
1 <a name="L34D3"></a>;; <b>USR-RANGE</b>
1 <a name="L34BC"></a>;; <b>usr-$</b>
1 <a name="L34B3"></a>;; <b>usr-no</b>
1 <a name="L34B0"></a>;; <b>IN-PK-STK</b>
1 <a name="L34AC"></a>;; <b>peek</b>
1 <a name="L34A5"></a>;; <b>in</b>
1 <a name="L3492"></a>;; <b>sgn</b>
1 <a name="L3483"></a>;; <b>INT-CASE</b>
1 <a name="L3474"></a>;; <b>NEG-TEST</b>
1 <a name="L346E"></a>;; <b>negate</b>
1 <a name="L346E"></a>;; <b>NEGATE</b>
1 <a name="L346A"></a>;; <b>abs</b>
1 <a name="L3453"></a>;; <b>G-LOOP</b>
1 <a name="L3449"></a>;; <b>series-xx</b>
1 <a name="L343E"></a>;; <b>SWAP-BYTE</b>
1 <a name="L343C"></a>;; <b>exchange</b>
1 <a name="L342D"></a>;; <b>st-mem-xx</b>
1 <a name="L341B"></a>;; <b>stk-const-xx</b>
1 <a name="L340F"></a>;; <b>get-mem-xx</b>
1 <a name="L3406"></a>;; <b>LOC-MEM</b>
1 <a name="L33F8"></a>;; <b>SKIP-NEXT</b>
1 <a name="L33F7"></a>;; <b>SKIP-CONS</b>
1 <a name="L33F1"></a>;; <b>STK-ZEROS</b>
1 <a name="L33DE"></a>;; <b>FORM-EXP</b>
1 <a name="L33C8"></a>;; <b>STK-CONST</b>
1 <a name="L33C6"></a>;; <b>stk-data</b>
1 <a name="L33C0"></a>;; <b>duplicate</b>
1 <a name="L33C0"></a>;; <b>MOVE-FP</b>
1 <a name="L33B4"></a>;; <b>STACK-NUM</b>
1 <a name="L33A9"></a>;; <b>TEST-5-SP</b>
1 <a name="L33A2"></a>;; <b>fp-calc-2</b>
1 <a name="L33A1"></a>;; <b>delete</b>
1 <a name="L338E"></a>;; <b>ENT-TABLE</b>
1 <a name="L338C"></a>;; <b>DOUBLE-A</b>
1 <a name="L3380"></a>;; <b>FIRST-3D</b>
1 <a name="L336C"></a>;; <b>SCAN-ENT</b>
1 <a name="L3365"></a>;; <b>RE-ENTRY</b>
1 <a name="L3362"></a>;; <b>GEN-ENT-2</b>
1 <a name="L335E"></a>;; <b>GEN-ENT-1</b>
1 <a name="L335B"></a>;; <b>CALCULATE</b>
1 <a name="L32D7"></a>;; <b>tbl-addrs</b>
1 <a name="L32D3"></a>;; <b>stk-ten</b> 00 00 0A 00 00
1 <a name="L32CE"></a>;; <b>stk-pi/2</b> 81 49 0F DA A2
1 <a name="L32CC"></a>;; <b>stk-half</b> 80 00 00 00 00
1 <a name="L32C8"></a>;; <b>stk-one</b> 00 00 01 00 00
1 <a name="L32C5"></a>;; <b>stk-zero</b> 00 00 00 00 00
1 <a name="L32BD"></a>;; <b>RS-STORE</b>
1 <a name="L32B2"></a>;; <b>RSTK-LOOP</b>
1 <a name="L32B1"></a>;; <b>RS-NRMLSE</b>
1 <a name="L3297"></a>;; <b>re-stack</b>
1 <a name="L3296"></a>;; <b>RESTK-SUB</b>
1 <a name="L3293"></a>;; <b>RE-ST-TWO</b>
1 <a name="L3290"></a>;; <b>IX-END</b>
1 <a name="L328A"></a>;; <b>LESS-MASK</b>
1 <a name="L3283"></a>;; <b>BITS-ZERO</b>
1 <a name="L327E"></a>;; <b>BYTE-ZERO</b>
1 <a name="L3272"></a>;; <b>NIL-BYTES</b>
1 <a name="L326D"></a>;; <b>X-LARGE</b>
1 <a name="L326C"></a>;; <b>T-EXPNENT</b>
1 <a name="L3267"></a>;; <b>T-STORE</b>
1 <a name="L3261"></a>;; <b>T-SHIFT</b>
1 <a name="L325E"></a>;; <b>T-TEST</b>
1 <a name="L3252"></a>;; <b>T-NUMERIC</b>
1 <a name="L323F"></a>;; <b>T-SMALL</b>
1 <a name="L3233"></a>;; <b>T-FIRST</b>
1 <a name="L3221"></a>;; <b>T-GR-ZERO</b>
1 <a name="L3214"></a>;; <b>truncate</b>
1 <a name="L31FA"></a>;; <b>COUNT-ONE</b>
1 <a name="L31F9"></a>;; <b>NO-RSTORE</b>
1 <a name="L31F2"></a>;; <b>SUBN-ONLY</b>
1 <a name="L31E2"></a>;; <b>DIV-START</b>
1 <a name="L31DB"></a>;; <b>div-34th</b>
1 <a name="L31D2"></a>;; <b>DIV-LOOP</b>
1 <a name="L31AF"></a>;; <b>division</b>
1 <a name="L31AD"></a>;; <b>REPORT-6</b>
1 <a name="L3195"></a>;; <b>OFLOW-CLR</b>
1 <a name="L3186"></a>;; <b>NORML-NOW</b>
1 <a name="L316E"></a>;; <b>SHIFT-ONE</b>
1 <a name="L316C"></a>;; <b>NORMALISE</b>
1 <a name="L315E"></a>;; <b>SKIP-ZERO</b>
1 <a name="L315D"></a>;; <b>ZERO-RSLT</b>
1 <a name="L3159"></a>;; <b>NEAR-ZERO</b>
1 <a name="L3155"></a>;; <b>TEST-NORM</b>
1 <a name="L3151"></a>;; <b>OFLW2-CLR</b>
1 <a name="L3146"></a>;; <b>OFLW1-CLR</b>
1 <a name="L313D"></a>;; <b>DIVN-EXPT</b>
1 <a name="L313B"></a>;; <b>MAKE-EXPT</b>
1 <a name="L3125"></a>;; <b>STRT-MLT</b>
1 <a name="L311B"></a>;; <b>NO-ADD</b>
1 <a name="L3114"></a>;; <b>MLT-LOOP</b>
1 <a name="L30F0"></a>;; <b>MULT-LONG</b>
1 <a name="L30EF"></a>;; <b>MULT-OFLW</b>
1 <a name="L30EA"></a>;; <b>MULT-RSLT</b>
1 <a name="L30CA"></a>;; <b>multiply</b>
1 <a name="L30C0"></a>;; <b>PREP-M/D</b>
1 <a name="L30BE"></a>;; <b>HL-END</b>
1 <a name="L30BC"></a>;; <b>HL-AGAIN</b>
1 <a name="L30B1"></a>;; <b>HL-LOOP</b>
1 <a name="L30A9"></a>;; <b>HL-HL*DE</b>
1 <a name="L30A5"></a>;; <b>GO-NC-MLT</b>
1 <a name="L30A3"></a>;; <b>END-COMPL</b>
1 <a name="L309F"></a>;; <b>ADD-REP-6</b>
1 <a name="L307C"></a>;; <b>TEST-NEG</b>
1 <a name="L3055"></a>;; <b>SHIFT-LEN</b>
1 <a name="L303E"></a>;; <b>FULL-ADDN</b>
1 <a name="L303C"></a>;; <b>ADDN-OFLW</b>
1 <a name="L3014"></a>;; <b>addition</b>
1 <a name="L300F"></a>;; <b>subtract</b>
1 <a name="L300D"></a>;; <b>ALL-ADDED</b>
1 <a name="L3004"></a>;; <b>ADD-BACK</b>
1 <a name="L2FFB"></a>;; <b>ZEROS-4/5</b>
1 <a name="L2FF9"></a>;; <b>ADDEND-0</b>
1 <a name="L2FE5"></a>;; <b>ONE-SHIFT</b>
1 <a name="L2FDD"></a>;; <b>SHIFT-FP</b>
1 <a name="L2FBA"></a>;; <b>FETCH-TWO</b>
1 <a name="L2FAF"></a>;; <b>NEG-BYTE</b>
1 <a name="L2F9B"></a>;; <b>PREP-ADD</b>
1 <a name="L2F8B"></a>;; <b>CA-10*A+C</b>
1 <a name="L2F85"></a>;; <b>PF-E-SIGN</b>
1 <a name="L2F83"></a>;; <b>PF-E-POS</b>
1 <a name="L2F6C"></a>;; <b>PF-E-FRMT</b>
1 <a name="L2F64"></a>;; <b>PF-DEC-0S</b>
1 <a name="L2F5E"></a>;; <b>PF-DC-OUT</b>
1 <a name="L2F59"></a>;; <b>PF-OUT-DT</b>
1 <a name="L2F52"></a>;; <b>PF-OUT-LP</b>
1 <a name="L2F4A"></a>;; <b>PF-E-SBRN</b>
1 <a name="L2F46"></a>;; <b>PF-NOT-E</b>
1 <a name="L2F2D"></a>;; <b>PF-COUNT</b>
1 <a name="L2F25"></a>;; <b>PF-R-BACK</b>
1 <a name="L2F18"></a>;; <b>PF-RND-LP</b>
1 <a name="L2F0C"></a>;; <b>PF-ROUND</b>
1 <a name="L2EEF"></a>;; <b>PF-FR-EXX</b>
1 <a name="L2EEC"></a>;; <b>PF-FR-DGT</b>
1 <a name="L2EDF"></a>;; <b>PF-FRN-LP</b>
1 <a name="L2ECF"></a>;; <b>PF-FRACTN</b>
1 <a name="L2ECB"></a>;; <b>PF-MORE</b>
1 <a name="L2EB8"></a>;; <b>PF-ALL-9</b>
1 <a name="L2EB3"></a>;; <b>PF-TEST-2</b>
1 <a name="L2EA9"></a>;; <b>PF-INSERT</b>
1 <a name="L2EA1"></a>;; <b>PF-DIGITS</b>
1 <a name="L2E8A"></a>;; <b>PF-BYTES</b>
1 <a name="L2E7B"></a>;; <b>PF-BITS</b>
1 <a name="L2E6F"></a>;; <b>PF-MEDIUM</b>
1 <a name="L2E56"></a>;; <b>PF-LARGE</b>
1 <a name="L2E24"></a>;; <b>PF-SMALL</b>
1 <a name="L2E1E"></a>;; <b>PF-SAVE</b>
1 <a name="L2E01"></a>;; <b>PF-LOOP</b>
1 <a name="L2DF8"></a>;; <b>PF-POSTVE</b>
1 <a name="L2DF2"></a>;; <b>PF-NEGTVE</b>
1 <a name="L2DE3"></a>;; <b>PRINT-FP</b>
1 <a name="L2DE1"></a>;; <b>FP-A-END</b>
1 <a name="L2DD5"></a>;; <b>FP-TO-A</b>
1 <a name="L2DC1"></a>;; <b>LOG(2^A)</b>
1 <a name="L2DAD"></a>;; <b>FP-DELETE</b>
1 <a name="L2DA2"></a>;; <b>FP-TO-BC</b>
1 <a name="L2D8E"></a>;; <b>INT-STORE</b>
1 <a name="L2D8C"></a>;; <b>p-int-sto</b>
1 <a name="L2D7F"></a>;; <b>INT-FETCH</b>
1 <a name="L2D7B"></a>;; <b>E-END</b>
1 <a name="L2D71"></a>;; <b>E-TST-END</b>
1 <a name="L2D6E"></a>;; <b>E-FETCH</b>
1 <a name="L2D6D"></a>;; <b>E-DIVSN</b>
1 <a name="L2D60"></a>;; <b>E-LOOP</b>
1 <a name="L2D55"></a>;; <b>E-SAVE</b>
1 <a name="L2D4F"></a>;; <b>e-to-fp</b>
1 <a name="L2D4F"></a>;; <b>E-TO-FP</b>
1 <a name="L2D40"></a>;; <b>NXT-DGT-2</b>
1 <a name="L2D3B"></a>;; <b>INT-TO-FP</b>
1 <a name="L2D2B"></a>;; <b>STACK-BC</b>
1 <a name="L2D28"></a>;; <b>STACK-A</b>
1 <a name="L2D22"></a>;; <b>STK-DIGIT</b>
1 <a name="L2D1B"></a>;; <b>NUMERIC</b>
1 <a name="L2D18"></a>;; <b>E-FP-JUMP</b>
1 <a name="L2CFF"></a>;; <b>ST-E-PART</b>
1 <a name="L2CFE"></a>;; <b>SIGN-DONE</b>
1 <a name="L2CF2"></a>;; <b>SIGN-FLAG</b>
1 <a name="L2CEB"></a>;; <b>E-FORMAT</b>
1 <a name="L2CDA"></a>;; <b>NXT-DGT-1</b>
1 <a name="L2CD5"></a>;; <b>DEC-STO-1</b>
1 <a name="L2CCF"></a>;; <b>DEC-RPT-C</b>
1 <a name="L2CCB"></a>;; <b>DECIMAL</b>
1 <a name="L2CB8"></a>;; <b>NOT-BIN</b>
1 <a name="L2CB3"></a>;; <b>BIN-END</b>
1 <a name="L2CA2"></a>;; <b>BIN-DIGIT</b>
1 <a name="L2C9B"></a>;; <b>DEC-TO-FP</b>
1 <a name="L2C8D"></a>;; <b>ALPHA</b>
1 <a name="L2C88"></a>;; <b>ALPHANUM</b>
1 <a name="L2C7F"></a>;; <b>DIM-SIZES</b>
1 <a name="L2C7C"></a>;; <b>DIM-CLEAR</b>
1 <a name="L2C2E"></a>;; <b>D-NO-LOOP</b>
1 <a name="L2C2D"></a>;; <b>D-SIZE</b>
1 <a name="L2C1F"></a>;; <b>D-LETTER</b>
1 <a name="L2C15"></a>;; <b>D-RUN</b>
1 <a name="L2C05"></a>;; <b>D-RPORT-C</b>
1 <a name="L2C02"></a>;; <b>DIM</b>
1 <a name="L2BF1"></a>;; <b>STK-FETCH</b>
1 <a name="L2BEA"></a>;; <b>L-FIRST</b>
1 <a name="L2BC6"></a>;; <b>L-STRING</b>
1 <a name="L2BC0"></a>;; <b>L-NEW$</b>
1 <a name="L2BAF"></a>;; <b>L-ADD$</b>
1 <a name="L2BA6"></a>;; <b>L-ENTER</b>
1 <a name="L2BA3"></a>;; <b>L-IN-W/S</b>
1 <a name="L2B9B"></a>;; <b>L-LENGTH</b>
1 <a name="L2B72"></a>;; <b>L-DELETE$</b>
1 <a name="L2B66"></a>;; <b>L-EXISTS</b>
1 <a name="L2B59"></a>;; <b>L-NUMERIC</b>
1 <a name="L2B4F"></a>;; <b>L-SINGLE</b>
1 <a name="L2B3E"></a>;; <b>L-CHAR</b>
1 <a name="L2B29"></a>;; <b>L-SPACES</b>
1 <a name="L2B1F"></a>;; <b>L-TEST-CH</b>
1 <a name="L2B0C"></a>;; <b>L-NO-SP</b>
1 <a name="L2B0B"></a>;; <b>L-EACH-CH</b>
1 <a name="L2AFF"></a>;; <b>LET</b>
1 <a name="L2AF4"></a>;; <b>GET-HL*DE</b>
1 <a name="L2AEE"></a>;; <b>DE,(DE+1)</b>
1 <a name="L2AEB"></a>;; <b>I-RESTORE</b>
1 <a name="L2AE8"></a>;; <b>I-CARRY</b>
1 <a name="L2ACD"></a>;; <b>INT-EXP2</b>
1 <a name="L2ACC"></a>;; <b>INT-EXP1</b>
1 <a name="L2AB6"></a>;; <b>STK-STORE</b>
1 <a name="L2AB2"></a>;; <b>STK-STO-$</b>
1 <a name="L2AB1"></a>;; <b>STK-ST-0</b>
1 <a name="L2AAD"></a>;; <b>SL-STORE</b>
1 <a name="L2AA8"></a>;; <b>SL-OVER</b>
1 <a name="L2A94"></a>;; <b>SL-DEFINE</b>
1 <a name="L2A81"></a>;; <b>SL-SECOND</b>
1 <a name="L2A7A"></a>;; <b>SL-RPT-C</b>
1 <a name="L2A52"></a>;; <b>SLICING</b>
1 <a name="L2A49"></a>;; <b>SV-SLICE?</b>
1 <a name="L2A48"></a>;; <b>SV-DIM</b>
1 <a name="L2A45"></a>;; <b>SV-SLICE</b>
1 <a name="L2A2C"></a>;; <b>SV-ELEM$</b>
1 <a name="L2A22"></a>;; <b>SV-NUMBER</b>
1 <a name="L2A20"></a>;; <b>REPORT-3</b>
1 <a name="L2A12"></a>;; <b>SV-RPT-C</b>
1 <a name="L29FB"></a>;; <b>SV-MULT</b>
1 <a name="L29EA"></a>;; <b>SV-LOOP</b>
1 <a name="L29E7"></a>;; <b>SV-COUNT</b>
1 <a name="L29E0"></a>;; <b>SV-CH-ADD</b>
1 <a name="L29D8"></a>;; <b>SV-CLOSE</b>
1 <a name="L29C3"></a>;; <b>SV-COMMA</b>
1 <a name="L29C0"></a>;; <b>SV-PTR</b>
1 <a name="L29AE"></a>;; <b>SV-ARRAYS</b>
1 <a name="L29A1"></a>;; <b>SV-SIMPLE$</b>
1 <a name="L2996"></a>;; <b>STK-VAR</b>
1 <a name="L2991"></a>;; <b>SFA-END</b>
1 <a name="L2981"></a>;; <b>SFA-MATCH</b>
1 <a name="L296B"></a>;; <b>SFA-CP-VR</b>
1 <a name="L295A"></a>;; <b>SFA-LOOP</b>
1 <a name="L2951"></a>;; <b>STK-F-ARG</b>
1 <a name="L294B"></a>;; <b>V-END</b>
1 <a name="L2943"></a>;; <b>V-PASS</b>
1 <a name="L293F"></a>;; <b>V-FOUND-2</b>
1 <a name="L293E"></a>;; <b>V-FOUND-1</b>
1 <a name="L2934"></a>;; <b>V-SYNTAX</b>
1 <a name="L2932"></a>;; <b>V-80-BYTE</b>
1 <a name="L292A"></a>;; <b>V-NEXT</b>
1 <a name="L2929"></a>;; <b>V-GET-PTR</b>
1 <a name="L2913"></a>;; <b>V-SPACES</b>
1 <a name="L2912"></a>;; <b>V-MATCHES</b>
1 <a name="L2900"></a>;; <b>V-EACH</b>
1 <a name="L28FD"></a>;; <b>V-RUN</b>
1 <a name="L28EF"></a>;; <b>V-RUN/SYN</b>
1 <a name="L28E3"></a>;; <b>V-TEST-FN</b>
1 <a name="L28DE"></a>;; <b>V-STR-VAR</b>
1 <a name="L28D4"></a>;; <b>V-CHAR</b>
1 <a name="L28B2"></a>;; <b>LOOK-VARS</b>
1 <a name="L28AB"></a>;; <b>FN-SKPOVR</b>
1 <a name="L288D"></a>;; <b>SF-VALUE</b>
1 <a name="L288B"></a>;; <b>REPORT-Q</b>
1 <a name="L2885"></a>;; <b>SF-R-BR-2</b>
1 <a name="L2852"></a>;; <b>SF-ARG-VL</b>
1 <a name="L2843"></a>;; <b>SF-ARG-LP</b>
1 <a name="L2831"></a>;; <b>SF-VALUES</b>
1 <a name="L2825"></a>;; <b>SF-NOT-FD</b>
1 <a name="L2814"></a>;; <b>SF-CP-DEF</b>
1 <a name="L2812"></a>;; <b>REPORT-P</b>
1 <a name="L2808"></a>;; <b>SF-FND-DF</b>
1 <a name="L2802"></a>;; <b>SF-ARGMT1</b>
1 <a name="L27F7"></a>;; <b>SF-RUN</b>
1 <a name="L27F4"></a>;; <b>SF-SYN-EN</b>
1 <a name="L27E9"></a>;; <b>SF-FLAG-6</b>
1 <a name="L27E6"></a>;; <b>SF-RPRT-C</b>
1 <a name="L27E4"></a>;; <b>SF-BRKT-2</b>
1 <a name="L27D9"></a>;; <b>SF-ARGMTS</b>
1 <a name="L27D0"></a>;; <b>SF-BRKT-1</b>
1 <a name="L27BD"></a>;; <b>S-FN-SBRN</b>
1 <a name="L27B0"></a>;; <b>tbl-priors</b>
1 <a name="L2795"></a>;; <b>tbl-of-ops</b>
1 <a name="L2790"></a>;; <b>S-NEXT</b>
1 <a name="L2788"></a>;; <b>S-NOT-AND</b>
1 <a name="L2773"></a>;; <b>S-TIGHTER</b>
1 <a name="L2770"></a>;; <b>S-LOOPEND</b>
1 <a name="L2764"></a>;; <b>S-RUNTEST</b>
1 <a name="L2761"></a>;; <b>S-RPORT-C2</b>
1 <a name="L275B"></a>;; <b>S-SYNTEST</b>
1 <a name="L274C"></a>;; <b>S-STK-LST</b>
1 <a name="L2734"></a>;; <b>S-LOOP</b>
1 <a name="L2723"></a>;; <b>S-OPERTR</b>
1 <a name="L2713"></a>;; <b>S-CONT-3</b>
1 <a name="L2712"></a>;; <b>S-CONT-2</b>
1 <a name="L270D"></a>;; <b>S-PUSH-PO</b>
1 <a name="L2707"></a>;; <b>S-NO-TO-$</b>
1 <a name="L26DF"></a>;; <b>S-NEGATE</b>
1 <a name="L26DD"></a>;; <b>S-CONT-1</b>
1 <a name="L26C9"></a>;; <b>S-LETTER</b>
1 <a name="L26C3"></a>;; <b>S-NUMERIC</b>
1 <a name="L26B6"></a>;; <b>S-SD-SKIP</b>
1 <a name="L26B5"></a>;; <b>S-STK-DEC</b>
1 <a name="L268D"></a>;; <b>S-DECIMAL</b>
1 <a name="L268D"></a>;; <b>S-BIN</b>
1 <a name="L2684"></a>;; <b>S-ALPHNUM</b>
1 <a name="L267B"></a>;; <b>S-POINT</b>
1 <a name="L2672"></a>;; <b>S-ATTR</b>
1 <a name="L2668"></a>;; <b>S-SCREEN$</b>
1 <a name="L2665"></a>;; <b>S-INK$-EN</b>
1 <a name="L2660"></a>;; <b>S-IK$-STK</b>
1 <a name="L2634"></a>;; <b>S-INKEY$</b>
1 <a name="L2630"></a>;; <b>S-PI-END</b>
1 <a name="L2627"></a>;; <b>S-PI</b>
1 <a name="L2625"></a>;; <b>S-RND-END</b>
1 <a name="L25F8"></a>;; <b>S-RND</b>
1 <a name="L25F5"></a>;; <b>S-FN</b>
1 <a name="L25E8"></a>;; <b>S-BRACKET</b>
1 <a name="L25DB"></a>;; <b>S-STRING</b>
1 <a name="L25D9"></a>;; <b>S-Q-PRMS</b>
1 <a name="L25CB"></a>;; <b>S-Q-COPY</b>
1 <a name="L25BE"></a>;; <b>S-Q-AGAIN</b>
1 <a name="L25B3"></a>;; <b>S-QUOTE</b>
1 <a name="L25AF"></a>;; <b>S-U-PLUS</b>
1 <a name="L2596"></a>;; <b>scan-func</b>
1 <a name="L2580"></a>;; <b>S-ATTR-S</b>
1 <a name="L257D"></a>;; <b>S-SCR-STO</b>
1 <a name="L2573"></a>;; <b>S-SCR-NXT</b>
1 <a name="L255D"></a>;; <b>S-SC-ROWS</b>
1 <a name="L255A"></a>;; <b>S-SC-MTCH</b>
1 <a name="L254F"></a>;; <b>S-SCRN-LP</b>
1 <a name="L2535"></a>;; <b>S-SCRN$-S</b>
1 <a name="L2530"></a>;; <b>SYNTAX-Z</b>
1 <a name="L252D"></a>;; <b>S-RPORT-C</b>
1 <a name="L2522"></a>;; <b>S-2-COORD</b>
1 <a name="L250F"></a>;; <b>S-QUOTE-S</b>
1 <a name="L24FF"></a>;; <b>S-LOOP-1</b>
1 <a name="L24FB"></a>;; <b>SCANNING</b>
1 <a name="L24F9"></a>;; <b>REPORT-Bc</b>
1 <a name="L24F7"></a>;; <b>D-L-RANGE</b>
1 <a name="L24EC"></a>;; <b>D-L-PLOT</b>
1 <a name="L24DF"></a>;; <b>D-L-STEP</b>
1 <a name="L24DB"></a>;; <b>D-L-HR-VT</b>
1 <a name="L24D4"></a>;; <b>D-L-DIAG</b>
1 <a name="L24CE"></a>;; <b>D-L-LOOP</b>
1 <a name="L24CB"></a>;; <b>DL-LARGER</b>
1 <a name="L24C4"></a>;; <b>DL-X-GE-Y</b>
1 <a name="L24B7"></a>;; <b>DRAW-LINE</b>
1 <a name="L2497"></a>;; <b>DRAW-SAVE</b>
1 <a name="L2495"></a>;; <b>USE-252</b>
1 <a name="L247D"></a>;; <b>CD-PRMS1</b>
1 <a name="L2477"></a>;; <b>LINE-DRAW</b>
1 <a name="L245F"></a>;; <b>ARC-END</b>
1 <a name="L2439"></a>;; <b>ARC-START</b>
1 <a name="L2425"></a>;; <b>ARC-LOOP</b>
1 <a name="L2420"></a>;; <b>DRW-STEPS</b>
1 <a name="L23C1"></a>;; <b>DR-PRMS</b>
1 <a name="L23A3"></a>;; <b>DR-SIN-NZ</b>
1 <a name="L238D"></a>;; <b>DR-3-PRMS</b>
1 <a name="L2382"></a>;; <b>DRAW</b>
1 <a name="L235A"></a>;; <b>C-ARC-GE1</b>
1 <a name="L233B"></a>;; <b>C-R-GRE-1</b>
1 <a name="L2320"></a>;; <b>CIRCLE</b>
1 <a name="L2314"></a>;; <b>STK-TO-A</b>
1 <a name="L2307"></a>;; <b>STK-TO-BC</b>
1 <a name="L2303"></a>;; <b>PLOT-END</b>
1 <a name="L22FD"></a>;; <b>PL-TST-IN</b>
1 <a name="L22F0"></a>;; <b>PLOT-LOOP</b>
1 <a name="L22E5"></a>;; <b>PLOT-SUB</b>
1 <a name="L22DC"></a>;; <b>PLOT</b>
1 <a name="L22D4"></a>;; <b>POINT-LP</b>
1 <a name="L22CB"></a>;; <b>POINT-SUB</b>
1 <a name="L22AA"></a>;; <b>PIXEL-ADD</b>
1 <a name="L22A6"></a>;; <b>BORDER-1</b>
1 <a name="L2294"></a>;; <b>BORDER</b>
1 <a name="L2287"></a>;; <b>CO-TEMP-E</b>
1 <a name="L227D"></a>;; <b>CO-TEMP-D</b>
1 <a name="L2273"></a>;; <b>CO-TEMP-C</b>
1 <a name="L226C"></a>;; <b>CO-CHANGE</b>
1 <a name="L2258"></a>;; <b>CO-TEMP-B</b>
1 <a name="L2257"></a>;; <b>CO-TEMP-A</b>
1 <a name="L2246"></a>;; <b>CO-TEMP-9</b>
1 <a name="L2244"></a>;; <b>REPORT-K</b>
1 <a name="L223E"></a>;; <b>CO-TEMP-8</b>
1 <a name="L2234"></a>;; <b>CO-TEMP-7</b>
1 <a name="L2228"></a>;; <b>CO-TEMP-6</b>
1 <a name="L2211"></a>;; <b>CO-TEMP-5</b>
1 <a name="L21FC"></a>;; <b>CO-TEMP-4</b>
1 <a name="L21F2"></a>;; <b>CO-TEMP-3</b>
1 <a name="L21E2"></a>;; <b>CO-TEMP-2</b>
1 <a name="L21E1"></a>;; <b>CO-TEMP-1</b>
1 <a name="L21D6"></a>;; <b>IN-CHAN-K</b>
1 <a name="L21D4"></a>;; <b>REPORT-H</b>
1 <a name="L21D0"></a>;; <b>IN-STOP</b>
1 <a name="L21CE"></a>;; <b>REPORT-Cb</b>
1 <a name="L21B9"></a>;; <b>IN-ASSIGN</b>
1 <a name="L21B2"></a>;; <b>IN-NEXT-2</b>
1 <a name="L21AF"></a>;; <b>IN-NEXT-1</b>
1 <a name="L219B"></a>;; <b>IN-VAR-6</b>
1 <a name="L2174"></a>;; <b>IN-VAR-5</b>
1 <a name="L2161"></a>;; <b>IN-VAR-4</b>
1 <a name="L215E"></a>;; <b>IN-VAR-3</b>
1 <a name="L2148"></a>;; <b>IN-VAR-2</b>
1 <a name="L213A"></a>;; <b>IN-VAR-1</b>
1 <a name="L2129"></a>;; <b>IN-PR-3</b>
1 <a name="L211C"></a>;; <b>IN-PR-2</b>
1 <a name="L211A"></a>;; <b>IN-PR-1</b>
1 <a name="L20FA"></a>;; <b>IN-PROMPT</b>
1 <a name="L20ED"></a>;; <b>IN-ITEM-3</b>
1 <a name="L20D8"></a>;; <b>IN-ITEM-2</b>
1 <a name="L20C1"></a>;; <b>IN-ITEM-1</b>
1 <a name="L20AD"></a>;; <b>INPUT-2</b>
1 <a name="L2096"></a>;; <b>INPUT-1</b>
1 <a name="L2089"></a>;; <b>INPUT</b>
1 <a name="L2070"></a>;; <b>STR-ALTER</b>
1 <a name="L206E"></a>;; <b>PR-POSN-4</b>
1 <a name="L2067"></a>;; <b>PR-POSN-3</b>
1 <a name="L2061"></a>;; <b>PR-POSN-2</b>
1 <a name="L204E"></a>;; <b>PR-POSN-1</b>
1 <a name="L2048"></a>;; <b>PR-ST-END</b>
1 <a name="L2045"></a>;; <b>PR-END-Z</b>
1 <a name="L203C"></a>;; <b>PR-STRING</b>
1 <a name="L2024"></a>;; <b>PR-ITEM-3</b>
1 <a name="L201E"></a>;; <b>PR-AT-TAB</b>
1 <a name="L200E"></a>;; <b>PR-ITEM-2</b>
1 <a name="L1FFC"></a>;; <b>PR-ITEM-1</b>
1 <a name="L1FF5"></a>;; <b>PRINT-CR</b>
1 <a name="L1FF2"></a>;; <b>PRINT-4</b>
1 <a name="L1FE5"></a>;; <b>PRINT-3</b>
1 <a name="L1FDF"></a>;; <b>PRINT-2</b>
1 <a name="L1FCF"></a>;; <b>PRINT-1</b>
1 <a name="L1FCD"></a>;; <b>PRINT</b>
1 <a name="L1FC9"></a>;; <b>LPRINT</b>
1 <a name="L1FC3"></a>;; <b>UNSTACK-Z</b>
1 <a name="L1FBD"></a>;; <b>DEF-FN-7</b>
1 <a name="L1FA6"></a>;; <b>DEF-FN-6</b>
1 <a name="L1F94"></a>;; <b>DEF-FN-5</b>
1 <a name="L1F89"></a>;; <b>DEF-FN-4</b>
1 <a name="L1F86"></a>;; <b>DEF-FN-3</b>
1 <a name="L1F7D"></a>;; <b>DEF-FN-2</b>
1 <a name="L1F6A"></a>;; <b>DEF-FN-1</b>
1 <a name="L1F60"></a>;; <b>DEF-FN</b>
1 <a name="L1F54"></a>;; <b>BREAK-KEY</b>
1 <a name="L1F4F"></a>;; <b>PAUSE-END</b>
1 <a name="L1F49"></a>;; <b>PAUSE-2</b>
1 <a name="L1F3D"></a>;; <b>PAUSE-1</b>
1 <a name="L1F3A"></a>;; <b>PAUSE</b>
1 <a name="L1F36"></a>;; <b>REPORT-7</b>
1 <a name="L1F23"></a>;; <b>RETURN</b>
1 <a name="L1F1A"></a>;; <b>free-mem</b>
1 <a name="L1F15"></a>;; <b>REPORT-4</b>
1 <a name="L1F05"></a>;; <b>TEST-ROOM</b>
1 <a name="L1EED"></a>;; <b>GO-SUB</b>
1 <a name="L1EDC"></a>;; <b>CLEAR-2</b>
1 <a name="L1EDA"></a>;; <b>REPORT-M</b>
1 <a name="L1EB7"></a>;; <b>CLEAR-1</b>
1 <a name="L1EAF"></a>;; <b>CLEAR-RUN</b>
1 <a name="L1EAC"></a>;; <b>CLEAR</b>
1 <a name="L1EA1"></a>;; <b>RUN</b>
1 <a name="L1E9F"></a>;; <b>REPORT-Bb</b>
1 <a name="L1E9C"></a>;; <b>FIND-I-1</b>
1 <a name="L1E99"></a>;; <b>FIND-INT2</b>
1 <a name="L1E94"></a>;; <b>FIND-INT1</b>
1 <a name="L1E8E"></a>;; <b>TWO-P-1</b>
1 <a name="L1E85"></a>;; <b>TWO-PARAM</b>
1 <a name="L1E80"></a>;; <b>POKE</b>
1 <a name="L1E7A"></a>;; <b>OUT</b>
1 <a name="L1E73"></a>;; <b>GO-TO-2</b>
1 <a name="L1E67"></a>;; <b>GO-TO</b>
1 <a name="L1E5F"></a>;; <b>CONTINUE</b>
1 <a name="L1E5A"></a>;; <b>RAND-1</b>
1 <a name="L1E4F"></a>;; <b>RANDOMIZE</b>
1 <a name="L1E45"></a>;; <b>REST-RUN</b>
1 <a name="L1E42"></a>;; <b>RESTORE</b>
1 <a name="L1E39"></a>;; <b>PASS-BY</b>
1 <a name="L1E37"></a>;; <b>DATA-2</b>
1 <a name="L1E2C"></a>;; <b>DATA-1</b>
1 <a name="L1E27"></a>;; <b>DATA</b>
1 <a name="L1E1E"></a>;; <b>READ-2</b>
1 <a name="L1E0A"></a>;; <b>READ-1</b>
1 <a name="L1E08"></a>;; <b>REPORT-E</b>
1 <a name="L1DED"></a>;; <b>READ</b>
1 <a name="L1DEC"></a>;; <b>READ-3</b>
1 <a name="L1DE9"></a>;; <b>NEXT-2</b>
1 <a name="L1DE2"></a>;; <b>NEXT-1</b>
1 <a name="L1DDA"></a>;; <b>NEXT-LOOP</b>
1 <a name="L1DD8"></a>;; <b>REPORT-1</b>
1 <a name="L1DAB"></a>;; <b>NEXT</b>
1 <a name="L1DA3"></a>;; <b>LOOK-P-2</b>
1 <a name="L1D8B"></a>;; <b>LOOK-P-1</b>
1 <a name="L1D86"></a>;; <b>LOOK-PROG</b>
1 <a name="L1D84"></a>;; <b>REPORT-I</b>
1 <a name="L1D7C"></a>;; <b>F-FOUND</b>
1 <a name="L1D64"></a>;; <b>F-LOOP</b>
1 <a name="L1D34"></a>;; <b>F-L-S</b>
1 <a name="L1D16"></a>;; <b>F-REORDER</b>
1 <a name="L1D10"></a>;; <b>F-USE-1</b>
1 <a name="L1D03"></a>;; <b>FOR</b>
1 <a name="L1D00"></a>;; <b>IF-1</b>
1 <a name="L1CF0"></a>;; <b>IF</b>
1 <a name="L1CEE"></a>;; <b>STOP</b>
1 <a name="L1CEE"></a>;; <b>REPORT-9</b>
1 <a name="L1CE6"></a>;; <b>USE-ZERO</b>
1 <a name="L1CDE"></a>;; <b>FETCH-NUM</b>
1 <a name="L1CDB"></a>;; <b>CLASS-0B</b>
1 <a name="L1CD6"></a>;; <b>CL-09-1</b>
1 <a name="L1CBE"></a>;; <b>CLASS-09</b>
1 <a name="L1C96"></a>;; <b>CLASS-07</b>
1 <a name="L1C8C"></a>;; <b>EXPT-EXP</b>
1 <a name="L1C8C"></a>;; <b>CLASS-0A</b>
1 <a name="L1C8A"></a>;; <b>REPORT-C</b>
1 <a name="L1C82"></a>;; <b>EXPT-1NUM</b>
1 <a name="L1C82"></a>;; <b>CLASS-06</b>
1 <a name="L1C7A"></a>;; <b>EXPT-2NUM</b>
1 <a name="L1C7A"></a>;; <b>CLASS-08</b>
1 <a name="L1C79"></a>;; <b>NEXT-2NUM</b>
1 <a name="L1C6C"></a>;; <b>CLASS-04</b>
1 <a name="L1C59"></a>;; <b>VAL-FET-2</b>
1 <a name="L1C56"></a>;; <b>VAL-FET-1</b>
1 <a name="L1C4E"></a>;; <b>CLASS-02</b>
1 <a name="L1C46"></a>;; <b>VAR-A-3</b>
1 <a name="L1C30"></a>;; <b>VAR-A-2</b>
1 <a name="L1C2E"></a>;; <b>REPORT-2</b>
1 <a name="L1C22"></a>;; <b>VAR-A-1</b>
1 <a name="L1C1F"></a>;; <b>CLASS-01</b>
1 <a name="L1C11"></a>;; <b>CLASS-05</b>
1 <a name="L1C10"></a>;; <b>CLASS-00</b>
1 <a name="L1C0D"></a>;; <b>CLASS-03</b>
1 <a name="L1C01"></a>;; <b>class-tbl</b>
1 <a name="L1BF4"></a>;; <b>STMT-NEXT</b>
1 <a name="L1BEE"></a>;; <b>CHECK-END</b>
1 <a name="L1BEC"></a>;; <b>REPORT-N</b>
1 <a name="L1BD1"></a>;; <b>NEXT-LINE</b>
1 <a name="L1BBF"></a>;; <b>LINE-USE</b>
1 <a name="L1BB3"></a>;; <b>LINE-END</b>
1 <a name="L1BB2"></a>;; <b>REM</b>
1 <a name="L1BB0"></a>;; <b>REPORT-0</b>
1 <a name="L1B9E"></a>;; <b>LINE-NEW</b>
1 <a name="L1B8A"></a>;; <b>LINE-RUN</b>
1 <a name="L1B7D"></a>;; <b>STMT-R-1</b>
1 <a name="L1B7B"></a>;; <b>REPORT-L</b>
1 <a name="L1B76"></a>;; <b>STMT-RET</b>
1 <a name="L1B6F"></a>;; <b>SEPARATOR</b>
1 <a name="L1B55"></a>;; <b>GET-PARAM</b>
1 <a name="L1B52"></a>;; <b>SCAN-LOOP</b>
1 <a name="L1B29"></a>;; <b>STMT-L-1</b>
1 <a name="L1B28"></a>;; <b>STMT-LOOP</b>
1 <a name="L1B17"></a>;; <b>LINE-SCAN</b>
1 <a name="L1B14"></a>;; <b>P-CAT</b>
1 <a name="L1B10"></a>;; <b>P-ERASE</b>
1 <a name="L1B0A"></a>;; <b>P-MOVE</b>
1 <a name="L1B06"></a>;; <b>P-FORMAT</b>
1 <a name="L1B02"></a>;; <b>P-CLOSE</b>
1 <a name="L1AFC"></a>;; <b>P-OPEN</b>
1 <a name="L1AF9"></a>;; <b>P-DEF-FN</b>
1 <a name="L1AF5"></a>;; <b>P-BORDER</b>
1 <a name="L1AF1"></a>;; <b>P-OUT</b>
1 <a name="L1AF0"></a>;; <b>P-OVER</b>
1 <a name="L1AEF"></a>;; <b>P-INVERSE</b>
1 <a name="L1AEE"></a>;; <b>P-BRIGHT</b>
1 <a name="L1AED"></a>;; <b>P-FLASH</b>
1 <a name="L1AEC"></a>;; <b>P-PAPER</b>
1 <a name="L1AEB"></a>;; <b>P-INK</b>
1 <a name="L1AE7"></a>;; <b>P-CIRCLE</b>
1 <a name="L1AE3"></a>;; <b>P-BEEP</b>
1 <a name="L1AE2"></a>;; <b>P-MERGE</b>
1 <a name="L1AE1"></a>;; <b>P-VERIFY</b>
1 <a name="L1AE0"></a>;; <b>P-LOAD</b>
1 <a name="L1ADF"></a>;; <b>P-SAVE</b>
1 <a name="L1ADC"></a>;; <b>P-LLIST</b>
1 <a name="L1AD9"></a>;; <b>P-LPRINT</b>
1 <a name="L1AD6"></a>;; <b>P-COPY</b>
1 <a name="L1AD2"></a>;; <b>P-DRAW</b>
1 <a name="L1ACF"></a>;; <b>P-RESTORE</b>
1 <a name="L1ACC"></a>;; <b>P-DATA</b>
1 <a name="L1AC9"></a>;; <b>P-READ</b>
1 <a name="L1AC5"></a>;; <b>P-PAUSE</b>
1 <a name="L1AC1"></a>;; <b>P-PLOT</b>
1 <a name="L1ABE"></a>;; <b>P-CLS</b>
1 <a name="L1ABB"></a>;; <b>P-CLEAR</b>
1 <a name="L1AB8"></a>;; <b>P-CONT</b>
1 <a name="L1AB5"></a>;; <b>P-RANDOM</b>
1 <a name="L1AB1"></a>;; <b>P-POKE</b>
1 <a name="L1AAE"></a>;; <b>P-LIST</b>
1 <a name="L1AAB"></a>;; <b>P-RUN</b>
1 <a name="L1AA8"></a>;; <b>P-NEW</b>
1 <a name="L1AA5"></a>;; <b>P-REM</b>
1 <a name="L1AA2"></a>;; <b>P-DIM</b>
1 <a name="L1A9F"></a>;; <b>P-INPUT</b>
1 <a name="L1A9C"></a>;; <b>P-PRINT</b>
1 <a name="L1A98"></a>;; <b>P-NEXT</b>
1 <a name="L1A90"></a>;; <b>P-FOR</b>
1 <a name="L1A8D"></a>;; <b>P-RETURN</b>
1 <a name="L1A8A"></a>;; <b>P-STOP</b>
1 <a name="L1A86"></a>;; <b>P-GO-SUB</b>
1 <a name="L1A81"></a>;; <b>P-IF</b>
1 <a name="L1A7D"></a>;; <b>P-GO-TO</b>
1 <a name="L1A7A"></a>;; <b>P-LET</b>
1 <a name="L1A48"></a>;; <b>offst-tbl</b>
1 <a name="L1A42"></a>;; <b>OUT-NUM-4</b>
1 <a name="L1A30"></a>;; <b>OUT-NUM-3</b>
1 <a name="L1A28"></a>;; <b>OUT-NUM-2</b>
1 <a name="L1A1B"></a>;; <b>OUT-NUM-1</b>
1 <a name="L1A15"></a>;; <b>E-L-1</b>
1 <a name="L19FB"></a>;; <b>E-LINE-NO</b>
1 <a name="L19E8"></a>;; <b>RECLAIM-2</b>
1 <a name="L19E5"></a>;; <b>RECLAIM-1</b>
1 <a name="L19DD"></a>;; <b>DIFFER</b>
1 <a name="L19DB"></a>;; <b>NEXT-O-5</b>
1 <a name="L19D6"></a>;; <b>NEXT-O-4</b>
1 <a name="L19D5"></a>;; <b>NEXT-O-3</b>
1 <a name="L19CE"></a>;; <b>NEXT-O-2</b>
1 <a name="L19C7"></a>;; <b>NEXT-O-1</b>
1 <a name="L19B8"></a>;; <b>NEXT-ONE</b>
1 <a name="L19B1"></a>;; <b>EACH-S-6</b>
1 <a name="L19AD"></a>;; <b>EACH-S-5</b>
1 <a name="L19A5"></a>;; <b>EACH-S-4</b>
1 <a name="L199A"></a>;; <b>EACH-S-3</b>
1 <a name="L1998"></a>;; <b>EACH-S-2</b>
1 <a name="L1990"></a>;; <b>EACH-S-1</b>
1 <a name="L198B"></a>;; <b>EACH-STMT</b>
1 <a name="L1988"></a>;; <b>not-used</b>
1 <a name="L1980"></a>;; <b>CP-LINES</b>
1 <a name="L1974"></a>;; <b>LINE-AD-1</b>
1 <a name="L196E"></a>;; <b>LINE-ADDR</b>
1 <a name="L196C"></a>;; <b>OUT-CH-3</b>
1 <a name="L1968"></a>;; <b>OUT-CH-2</b>
1 <a name="L195A"></a>;; <b>OUT-CH-1</b>
1 <a name="L1937"></a>;; <b>OUT-CHAR</b>
1 <a name="L192B"></a>;; <b>OUT-SP-1</b>
1 <a name="L192A"></a>;; <b>OUT-SP-NO</b>
1 <a name="L1925"></a>;; <b>OUT-SP-2</b>
1 <a name="L191C"></a>;; <b>LN-STORE</b>
1 <a name="L190F"></a>;; <b>LN-FETCH</b>
1 <a name="L1909"></a>;; <b>OUT-C-2</b>
1 <a name="L18F3"></a>;; <b>OUT-C-1</b>
1 <a name="L18E1"></a>;; <b>OUT-CURS</b>
1 <a name="L18C1"></a>;; <b>OUT-FLASH</b>
1 <a name="L18B6"></a>;; <b>NUMBER</b>
1 <a name="L18B4"></a>;; <b>OUT-LINE6</b>
1 <a name="L18A1"></a>;; <b>OUT-LINE5</b>
1 <a name="L1894"></a>;; <b>OUT-LINE4</b>
1 <a name="L1881"></a>;; <b>OUT-LINE3</b>
1 <a name="L187D"></a>;; <b>OUT-LINE2</b>
1 <a name="L1865"></a>;; <b>OUT-LINE1</b>
1 <a name="L1855"></a>;; <b>OUT-LINE</b>
1 <a name="L1835"></a>;; <b>LIST-ALL-2</b>
1 <a name="L1833"></a>;; <b>LIST-ALL</b>
1 <a name="L1822"></a>;; <b>LIST-5</b>
1 <a name="L181F"></a>;; <b>LIST-4</b>
1 <a name="L181A"></a>;; <b>LIST-3</b>
1 <a name="L1814"></a>;; <b>LIST-2</b>
1 <a name="L17FB"></a>;; <b>LIST-1</b>
1 <a name="L17F9"></a>;; <b>LIST</b>
1 <a name="L17F5"></a>;; <b>LLIST</b>
1 <a name="L17ED"></a>;; <b>AUTO-L-4</b>
1 <a name="L17E4"></a>;; <b>AUTO-L-3</b>
1 <a name="L17E1"></a>;; <b>AUTO-L-2</b>
1 <a name="L17CE"></a>;; <b>AUTO-L-1</b>
1 <a name="L1795"></a>;; <b>AUTO-LIST</b>
1 <a name="L1793"></a>;; <b>CAT-ETC</b>
1 <a name="L178B"></a>;; <b>OPEN-END</b>
1 <a name="L1789"></a>;; <b>OPEN-P</b>
1 <a name="L1785"></a>;; <b>OPEN-S</b>
1 <a name="L1781"></a>;; <b>OPEN-K</b>
1 <a name="L177A"></a>;; <b>op-str-lu</b>
1 <a name="L1767"></a>;; <b>OPEN-3</b>
1 <a name="L1765"></a>;; <b>REPORT-Fb</b>
1 <a name="L175D"></a>;; <b>OPEN-2</b>
1 <a name="L1756"></a>;; <b>OPEN-1</b>
1 <a name="L1736"></a>;; <b>OPEN</b>
1 <a name="L1727"></a>;; <b>STR-DATA1</b>
1 <a name="L1725"></a>;; <b>REPORT-Ob</b>
1 <a name="L171E"></a>;; <b>STR-DATA</b>
1 <a name="L171C"></a>;; <b>CLOSE-STR</b>
1 <a name="L1716"></a>;; <b>cl-str-lu</b>
1 <a name="L1708"></a>;; <b>ROM_TRAP</b>
1 <a name="L1701"></a>;; <b>CLOSE-2</b>
1 <a name="L16FC"></a>;; <b>CLOSE-1</b>
1 <a name="L16E5"></a>;; <b>CLOSE</b>
1 <a name="L16DC"></a>;; <b>INDEXER</b>
1 <a name="L16DB"></a>;; <b>INDEXER-1</b>
1 <a name="L16D4"></a>;; <b>REC-EDIT</b>
1 <a name="L16C5"></a>;; <b>SET-STK</b>
1 <a name="L16BF"></a>;; <b>SET-WORK</b>
1 <a name="L16B0"></a>;; <b>SET-MIN</b>
1 <a name="L169E"></a>;; <b>RESERVE</b>
1 <a name="L1695"></a>;; <b>LINE-NO</b>
1 <a name="L1691"></a>;; <b>LINE-NO-A</b>
1 <a name="L168F"></a>;; <b>LINE-ZERO</b>
1 <a name="L167F"></a>;; <b>PTR-DONE</b>
1 <a name="L166B"></a>;; <b>PTR-NEXT</b>
1 <a name="L1664"></a>;; <b>POINTERS</b>
1 <a name="L1655"></a>;; <b>MAKE-ROOM</b>
1 <a name="L1652"></a>;; <b>ONE-SPACE</b>
1 <a name="L164D"></a>;; <b>CHAN-P</b>
1 <a name="L1646"></a>;; <b>CHAN-S-1</b>
1 <a name="L1642"></a>;; <b>CHAN-S</b>
1 <a name="L1634"></a>;; <b>CHAN-K</b>
1 <a name="L162D"></a>;; <b>chn-cd-lu</b>
1 <a name="L162C"></a>;; <b>CALL-JUMP</b>
1 <a name="L1615"></a>;; <b>CHAN-FLAG</b>
1 <a name="L1610"></a>;; <b>CHAN-OP-1</b>
1 <a name="L160E"></a>;; <b>REPORT-Oa</b>
1 <a name="L1601"></a>;; <b>CHAN-OPEN</b>
1 <a name="L15F7"></a>;; <b>CALL-SUB</b>
1 <a name="L15F2"></a>;; <b>PRINT-A-2</b>
1 <a name="L15EF"></a>;; <b>OUT-CODE</b>
1 <a name="L15E6"></a>;; <b>INPUT-AD</b>
1 <a name="L15E4"></a>;; <b>REPORT-8</b>
1 <a name="L15DE"></a>;; <b>WAIT-KEY1</b>
1 <a name="L15D4"></a>;; <b>WAIT-KEY</b>
1 <a name="L15C6"></a>;; <b>init-strm</b>
1 <a name="L15C4"></a>;; <b>REPORT-J</b>
1 <a name="L15AF"></a>;; <b>init-chan</b>
1 <a name="L15AB"></a>;; <b>MAIN-ADD2</b>
1 <a name="L157D"></a>;; <b>MAIN-ADD1</b>
1 <a name="L155D"></a>;; <b>MAIN-ADD</b>
1 <a name="L1555"></a>;; <b>REPORT-G</b>
1 <a name="L1539"></a>;; <b>copyright</b>
1 <a name="L1537"></a>;; <b>comma-sp</b>
1 <a name="L1391"></a>;; <b>rpt-mesgs</b>
1 <a name="L1386"></a>;; <b>MAIN-9</b>
1 <a name="L1384"></a>;; <b>MAIN-8</b>
1 <a name="L1376"></a>;; <b>MAIN-7</b>
1 <a name="L1373"></a>;; <b>MAIN-6</b>
1 <a name="L133C"></a>;; <b>MAIN-5</b>
1 <a name="L1313"></a>;; <b>MAIN-G</b>
1 <a name="L1303"></a>;; <b>MAIN-4</b>
1 <a name="L12CF"></a>;; <b>MAIN-3</b>
1 <a name="L12AC"></a>;; <b>MAIN-2</b>
1 <a name="L12A9"></a>;; <b>MAIN-1</b>
1 <a name="L12A2"></a>;; <b>MAIN-EXEC</b>
1 <a name="L121C"></a>;; <b>NMI_VECT</b>
1 <a name="L1219"></a>;; <b>RAM-SET</b>
1 <a name="L11EF"></a>;; <b>RAM-DONE</b>
1 <a name="L11E2"></a>;; <b>RAM-READ</b>
1 <a name="L11DC"></a>;; <b>RAM-FILL</b>
1 <a name="L11DA"></a>;; <b>ram-check</b>
1 <a name="L11CB"></a>;; <b>START-NEW</b>
1 <a name="L11B7"></a>;; <b>NEW</b>
1 <a name="L11A7"></a>;; <b>REMOVE-FP</b>
1 <a name="L1195"></a>;; <b>SET-DE</b>
1 <a name="L1190"></a>;; <b>SET-HL</b>
1 <a name="L117E"></a>;; <b>ED-C-END</b>
1 <a name="L117C"></a>;; <b>ED-C-DONE</b>
1 <a name="L1167"></a>;; <b>ED-FULL</b>
1 <a name="L115E"></a>;; <b>ED-SPACES</b>
1 <a name="L1150"></a>;; <b>ED-BLANK</b>
1 <a name="L111D"></a>;; <b>ED-COPY</b>
1 <a name="L111B"></a>;; <b>KEY-DONE2</b>
1 <a name="L1113"></a>;; <b>KEY-CHAN</b>
1 <a name="L110D"></a>;; <b>KEY-NEXT</b>
1 <a name="L1105"></a>;; <b>KEY-DATA</b>
1 <a name="L10FA"></a>;; <b>KEY-CONTR</b>
1 <a name="L10F4"></a>;; <b>KEY-FLAG</b>
1 <a name="L10E6"></a>;; <b>KEY-MODE</b>
1 <a name="L10DB"></a>;; <b>KEY-M-CL</b>
1 <a name="L10A8"></a>;; <b>KEY-INPUT</b>
1 <a name="L1097"></a>;; <b>CLEAR-SP</b>
1 <a name="L107F"></a>;; <b>ED-ERROR</b>
1 <a name="L107C"></a>;; <b>ED-GRAPH</b>
1 <a name="L1076"></a>;; <b>ED-SYMBOL</b>
1 <a name="L106E"></a>;; <b>ED-LIST</b>
1 <a name="L1059"></a>;; <b>ED-UP</b>
1 <a name="L1051"></a>;; <b>ED-EDGE-2</b>
1 <a name="L103E"></a>;; <b>ED-EDGE-1</b>
1 <a name="L1031"></a>;; <b>ED-EDGE</b>
1 <a name="L1026"></a>;; <b>ED-END</b>
1 <a name="L1024"></a>;; <b>ED-ENTER</b>
1 <a name="L101E"></a>;; <b>ED-IGNORE</b>
1 <a name="L1015"></a>;; <b>ED-DELETE</b>
1 <a name="L1011"></a>;; <b>ED-CUR</b>
1 <a name="L100C"></a>;; <b>ED-RIGHT</b>
1 <a name="L1007"></a>;; <b>ED-LEFT</b>
1 <a name="L1001"></a>;; <b>ED-STOP</b>
1 <a name="L0FF3"></a>;; <b>ED-DOWN</b>
1 <a name="L0FA9"></a>;; <b>ED-EDIT</b>
1 <a name="L0FA0"></a>;; <b>ed-keys-t</b>
1 <a name="L0F92"></a>;; <b>ED-KEYS</b>
1 <a name="L0F8B"></a>;; <b>ADD-CH-1</b>
1 <a name="L0F81"></a>;; <b>ADD-CHAR</b>
1 <a name="L0F6C"></a>;; <b>ED-CONTR</b>
1 <a name="L0F38"></a>;; <b>ED-LOOP</b>
1 <a name="L0F30"></a>;; <b>ED-AGAIN</b>
1 <a name="L0F2C"></a>;; <b>EDITOR</b>
1 <a name="L0F1E"></a>;; <b>COPY-L-5</b>
1 <a name="L0F18"></a>;; <b>COPY-L-4</b>
1 <a name="L0F14"></a>;; <b>COPY-L-3</b>
1 <a name="L0F0C"></a>;; <b>COPY-L-2</b>
1 <a name="L0F0A"></a>;; <b>REPORT-Dc</b>
1 <a name="L0EFD"></a>;; <b>COPY-L-1</b>
1 <a name="L0EF4"></a>;; <b>COPY-LINE</b>
1 <a name="L0EE7"></a>;; <b>PRB-BYTES</b>
1 <a name="L0EDF"></a>;; <b>CLEAR-PRB</b>
1 <a name="L0EDA"></a>;; <b>COPY-END</b>
1 <a name="L0ED3"></a>;; <b>COPY-3</b>
1 <a name="L0ECD"></a>;; <b>COPY-BUFF</b>
1 <a name="L0EC9"></a>;; <b>COPY-2</b>
1 <a name="L0EB2"></a>;; <b>COPY-1</b>
1 <a name="L0EAC"></a>;; <b>COPY</b>
1 <a name="L0E9B"></a>;; <b>CL-ADDR</b>
1 <a name="L0E88"></a>;; <b>CL-ATTR</b>
1 <a name="L0E80"></a>;; <b>CL-LINE-3</b>
1 <a name="L0E4D"></a>;; <b>CL-LINE-2</b>
1 <a name="L0E4A"></a>;; <b>CL-LINE-1</b>
1 <a name="L0E44"></a>;; <b>CL-LINE</b>
1 <a name="L0E19"></a>;; <b>CL-SCR-3</b>
1 <a name="L0E0D"></a>;; <b>CL-SCR-2</b>
1 <a name="L0E05"></a>;; <b>CL-SCR-1</b>
1 <a name="L0E00"></a>;; <b>CL-SCROLL</b>
1 <a name="L0DFE"></a>;; <b>CL-SC-ALL</b>
1 <a name="L0DF4"></a>;; <b>CL-SET-2</b>
1 <a name="L0DEE"></a>;; <b>CL-SET-1</b>
1 <a name="L0DD9"></a>;; <b>CL-SET</b>
1 <a name="L0DAF"></a>;; <b>CL-ALL</b>
1 <a name="L0DA0"></a>;; <b>CL-CHAN-A</b>
1 <a name="L0D94"></a>;; <b>CL-CHAN</b>
1 <a name="L0D8E"></a>;; <b>CLS-3</b>
1 <a name="L0D89"></a>;; <b>CLS-2</b>
1 <a name="L0D87"></a>;; <b>CLS-1</b>
1 <a name="L0D6E"></a>;; <b>CLS-LOWER</b>
1 <a name="L0D6B"></a>;; <b>CLS</b>
1 <a name="L0D65"></a>;; <b>TEMPS-2</b>
1 <a name="L0D5B"></a>;; <b>TEMPS-1</b>
1 <a name="L0D4D"></a>;; <b>TEMPS</b>
1 <a name="L0D2D"></a>;; <b>PO-SCR-4B</b>
1 <a name="L0D1C"></a>;; <b>PO-SCR-4A</b>
1 <a name="L0D02"></a>;; <b>PO-SCR-4</b>
1 <a name="L0D00"></a>;; <b>REPORT-D</b>
1 <a name="L0CF8"></a>;; <b>scrl-mssg</b>
1 <a name="L0CF0"></a>;; <b>PO-SCR-3A</b>
1 <a name="L0CD2"></a>;; <b>PO-SCR-3</b>
1 <a name="L0C88"></a>;; <b>PO-SCR-2</b>
1 <a name="L0C86"></a>;; <b>REPORT-5</b>
1 <a name="L0C55"></a>;; <b>PO-SCR</b>
1 <a name="L0C44"></a>;; <b>PO-STEP</b>
1 <a name="L0C41"></a>;; <b>PO-SEARCH</b>
1 <a name="L0C3B"></a>;; <b>PO-SAVE</b>
1 <a name="L0C35"></a>;; <b>PO-TR-SP</b>
1 <a name="L0C22"></a>;; <b>PO-EACH</b>
1 <a name="L0C14"></a>;; <b>PO-TABLE</b>
1 <a name="L0C10"></a>;; <b>PO-TOKENS</b>
1 <a name="L0C0A"></a>;; <b>PO-MSG</b>
1 <a name="L0C08"></a>;; <b>PO-ATTR-2</b>
1 <a name="L0BFA"></a>;; <b>PO-ATTR-1</b>
1 <a name="L0BDB"></a>;; <b>PO-ATTR</b>
1 <a name="L0BD3"></a>;; <b>PR-ALL-6</b>
1 <a name="L0BC1"></a>;; <b>PR-ALL-5</b>
1 <a name="L0BB7"></a>;; <b>PR-ALL-4</b>
1 <a name="L0BB6"></a>;; <b>PR-ALL-3</b>
1 <a name="L0BA4"></a>;; <b>PR-ALL-2</b>
1 <a name="L0B93"></a>;; <b>PR-ALL-1</b>
1 <a name="L0B7F"></a>;; <b>PR-ALL</b>
1 <a name="L0B76"></a>;; <b>PO-CHAR-3</b>
1 <a name="L0B6A"></a>;; <b>PO-CHAR-2</b>
1 <a name="L0B65"></a>;; <b>PO-CHAR</b>
1 <a name="L0B5F"></a>;; <b>PO-T</b>
1 <a name="L0B4C"></a>;; <b>PO-GR-3</b>
1 <a name="L0B3E"></a>;; <b>PO-GR-2</b>
1 <a name="L0B38"></a>;; <b>PO-GR-1</b>
1 <a name="L0B24"></a>;; <b>PO-ANY</b>
1 <a name="L0B1D"></a>;; <b>PO-F-PR</b>
1 <a name="L0B03"></a>;; <b>PO-FETCH</b>
1 <a name="L0AFC"></a>;; <b>PO-ST-PR</b>
1 <a name="L0AF0"></a>;; <b>PO-ST-E</b>
1 <a name="L0ADC"></a>;; <b>PO-STORE</b>
1 <a name="L0AD9"></a>;; <b>PO-ABLE</b>
1 <a name="L0AD0"></a>;; <b>PO-SPACE</b>
1 <a name="L0AC3"></a>;; <b>PO-FILL</b>
1 <a name="L0AC2"></a>;; <b>PO-TAB</b>
1 <a name="L0ABF"></a>;; <b>PO-AT-SET</b>
1 <a name="L0AAC"></a>;; <b>PO-AT-ERR</b>
1 <a name="L0A87"></a>;; <b>PO-CONT</b>
1 <a name="L0A80"></a>;; <b>PO-CHANGE</b>
1 <a name="L0A7D"></a>;; <b>PO-TV-1</b>
1 <a name="L0A7A"></a>;; <b>PO-1-OPER</b>
1 <a name="L0A75"></a>;; <b>PO-2-OPER</b>
1 <a name="L0A6D"></a>;; <b>PO-TV-2</b>
1 <a name="L0A69"></a>;; <b>PO-QUEST</b>
1 <a name="L0A5F"></a>;; <b>PO-COMMA</b>
1 <a name="L0A4F"></a>;; <b>PO-ENTER</b>
1 <a name="L0A3D"></a>;; <b>PO-RIGHT</b>
1 <a name="L0A3A"></a>;; <b>PO-BACK-3</b>
1 <a name="L0A38"></a>;; <b>PO-BACK-2</b>
1 <a name="L0A23"></a>;; <b>PO-BACK-1</b>
1 <a name="L0A11"></a>;; <b>ctlchrtab</b>
1 <a name="L09F4"></a>;; <b>PRINT-OUT</b>
1 <a name="L09A1"></a>;; <b>tape-msgs</b>
1 <a name="L0991"></a>;; <b>SA-1-SEC</b>
1 <a name="L0970"></a>;; <b>SA-CONTRL</b>
1 <a name="L0958"></a>;; <b>ME-ENT-3</b>
1 <a name="L0955"></a>;; <b>ME-ENT-2</b>
1 <a name="L093E"></a>;; <b>ME-ENT-1</b>
1 <a name="L092C"></a>;; <b>ME-ENTER</b>
1 <a name="L0923"></a>;; <b>ME-VAR-L2</b>
1 <a name="L0921"></a>;; <b>ME-VAR-L1</b>
1 <a name="L091E"></a>;; <b>ME-OLD-V4</b>
1 <a name="L0912"></a>;; <b>ME-OLD-V3</b>
1 <a name="L0909"></a>;; <b>ME-OLD-V2</b>
1 <a name="L0901"></a>;; <b>ME-OLD-V1</b>
1 <a name="L08F9"></a>;; <b>ME-OLD-VP</b>
1 <a name="L08F0"></a>;; <b>ME-VAR-LP</b>
1 <a name="L08EB"></a>;; <b>ME-NEW-L2</b>
1 <a name="L08DF"></a>;; <b>ME-OLD-L1</b>
1 <a name="L08D7"></a>;; <b>ME-OLD-LP</b>
1 <a name="L08D2"></a>;; <b>ME-NEW-LP</b>
1 <a name="L08B6"></a>;; <b>ME-CONTRL</b>
1 <a name="L08AD"></a>;; <b>LD-PROG-1</b>
1 <a name="L0873"></a>;; <b>LD-PROG</b>
1 <a name="L084C"></a>;; <b>LD-DATA-1</b>
1 <a name="L082E"></a>;; <b>LD-DATA</b>
1 <a name="L0825"></a>;; <b>LD-CONT-2</b>
1 <a name="L0819"></a>;; <b>LD-CONT-1</b>
1 <a name="L0808"></a>;; <b>LD-CONTRL</b>
1 <a name="L0806"></a>;; <b>REPORT-R</b>
1 <a name="L0802"></a>;; <b>LD-BLOCK</b>
1 <a name="L0800"></a>;; <b>VR-CONT-3</b>
1 <a name="L07F4"></a>;; <b>VR-CONT-2</b>
1 <a name="L07E9"></a>;; <b>VR-CONT-1</b>
1 <a name="L07CB"></a>;; <b>VR-CONTRL</b>
1 <a name="L07AD"></a>;; <b>LD-CH-PR</b>
1 <a name="L07A6"></a>;; <b>LD-NAME</b>
1 <a name="L078A"></a>;; <b>LD-TYPE</b>
1 <a name="L0767"></a>;; <b>LD-LOOK-H</b>
1 <a name="L075A"></a>;; <b>SA-ALL</b>
1 <a name="L073A"></a>;; <b>SA-TYPE-0</b>
1 <a name="L0723"></a>;; <b>SA-LINE-1</b>
1 <a name="L0716"></a>;; <b>SA-LINE</b>
1 <a name="L0710"></a>;; <b>SA-TYPE-3</b>
1 <a name="L06F9"></a>;; <b>SA-CODE-4</b>
1 <a name="L06F5"></a>;; <b>SA-CODE-3</b>
1 <a name="L06F0"></a>;; <b>SA-CODE-2</b>
1 <a name="L06E1"></a>;; <b>SA-CODE-1</b>
1 <a name="L06C3"></a>;; <b>SA-CODE</b>
1 <a name="L06A0"></a>;; <b>SA-SCR$</b>
1 <a name="L0692"></a>;; <b>SA-DATA-1</b>
1 <a name="L068F"></a>;; <b>SA-V-TYPE</b>
1 <a name="L0685"></a>;; <b>SA-V-NEW</b>
1 <a name="L0672"></a>;; <b>SA-V-OLD</b>
1 <a name="L0670"></a>;; <b>REPORT-2a</b>
1 <a name="L0652"></a>;; <b>SA-DATA</b>
1 <a name="L064B"></a>;; <b>SA-NAME</b>
1 <a name="L0644"></a>;; <b>SA-NULL</b>
1 <a name="L0642"></a>;; <b>REPORT-Fa</b>
1 <a name="L0629"></a>;; <b>SA-BLANK</b>
1 <a name="L0621"></a>;; <b>SA-SPACE</b>
1 <a name="L0605"></a>;; <b>SAVE-ETC</b>
1 <a name="L05ED"></a>;; <b>LD-SAMPLE</b>
1 <a name="L05E9"></a>;; <b>LD-DELAY</b>
1 <a name="L05E7"></a>;; <b>LD-EDGE-1</b>
1 <a name="L05E3"></a>;; <b>LD-EDGE-2</b>
1 <a name="L05CA"></a>;; <b>LD-8-BITS</b>
1 <a name="L05C8"></a>;; <b>LD-MARKER</b>
1 <a name="L05C4"></a>;; <b>LD-DEC</b>
1 <a name="L05C2"></a>;; <b>LD-NEXT</b>
1 <a name="L05BD"></a>;; <b>LD-VERIFY</b>
1 <a name="L05B3"></a>;; <b>LD-FLAG</b>
1 <a name="L05A9"></a>;; <b>LD-LOOP</b>
1 <a name="L058F"></a>;; <b>LD-SYNC</b>
1 <a name="L0580"></a>;; <b>LD-LEADER</b>
1 <a name="L0574"></a>;; <b>LD-WAIT</b>
1 <a name="L056C"></a>;; <b>LD-START</b>
1 <a name="L056B"></a>;; <b>LD-BREAK</b>
1 <a name="L0556"></a>;; <b>LD-BYTES</b>
1 <a name="L0554"></a>;; <b>SA/LD-END</b>
1 <a name="L0552"></a>;; <b>REPORT-Da</b>
1 <a name="L053F"></a>;; <b>SA/LD-RET</b>
1 <a name="L053C"></a>;; <b>SA-DELAY</b>
1 <a name="L0525"></a>;; <b>SA-8-BITS</b>
1 <a name="L051C"></a>;; <b>SA-OUT</b>
1 <a name="L051A"></a>;; <b>SA-SET</b>
1 <a name="L0514"></a>;; <b>SA-BIT-1</b>
1 <a name="L0511"></a>;; <b>SA-BIT-2</b>
1 <a name="L050E"></a>;; <b>SA-PARITY</b>
1 <a name="L0507"></a>;; <b>SA-START</b>
1 <a name="L0505"></a>;; <b>SA-LOOP-P</b>
1 <a name="L04FE"></a>;; <b>SA-LOOP</b>
1 <a name="L04F2"></a>;; <b>SA-SYNC-2</b>
1 <a name="L04EA"></a>;; <b>SA-SYNC-1</b>
1 <a name="L04D8"></a>;; <b>SA-LEADER</b>
1 <a name="L04D0"></a>;; <b>SA-FLAG</b>
1 <a name="L04C2"></a>;; <b>SA-BYTES</b>
1 <a name="L04AA"></a>;; <b>zx81-name</b>
1 <a name="L046E"></a>;; <b>semi-tone</b> five byte fp decimal freq note (middle)
1 <a name="L046C"></a>;; <b>REPORT-B</b>
1 <a name="L0427"></a>;; <b>BE-OCTAVE</b> ; A=# semitones above 5 octaves below middle C
1 <a name="L0425"></a>;; <b>BE-I-OK</b> ; here, -60<=pitch<=127
1 <a name="L03F8"></a>;; <b>beep</b>
1 <a name="L03F6"></a>;; <b>BE-END</b>
1 <a name="L03F2"></a>;; <b>BE-AGAIN</b> ; halfway through cycle
1 <a name="L03D4"></a>;; <b>BE-IX+0</b>
1 <a name="L03D3"></a>;; <b>BE-IX+1</b>
1 <a name="L03D2"></a>;; <b>BE-IX+2</b>
1 <a name="L03D1"></a>;; <b>BE-IX+3</b>
1 <a name="L03B5"></a>;; <b>BEEPER</b>
1 <a name="L03B2"></a>;; <b>K-@-CHAR</b>
1 <a name="L039D"></a>;; <b>K-KLC-DGT</b>
1 <a name="L0389"></a>;; <b>K-GRA-DGT</b>
1 <a name="L0367"></a>;; <b>K-DIGIT</b>
1 <a name="L0364"></a>;; <b>K-TOKENS</b>
1 <a name="L034F"></a>;; <b>K-KLC-LET</b>
1 <a name="L034A"></a>;; <b>K-LOOK-UP</b>
1 <a name="L0341"></a>;; <b>addit</b>
1 <a name="L0341"></a>;; <b>K-E-LET</b>
1 <a name="L0333"></a>;; <b>K-DECODE</b>
1 <a name="L032C"></a>;; <b>K-MAIN</b>
1 <a name="L031E"></a>;; <b>K-TEST</b>
1 <a name="L0310"></a>;; <b>K-REPEAT</b>
1 <a name="L0308"></a>;; <b>K-END</b>
1 <a name="L02F1"></a>;; <b>K-NEW</b>
1 <a name="L02D1"></a>;; <b>K-CH-SET</b>
1 <a name="L02C6"></a>;; <b>K-ST-LOOP</b>
1 <a name="L02BF"></a>;; <b>KEYBOARD</b>
1 <a name="L02AB"></a>;; <b>KEY-DONE</b>
1 <a name="L02A1"></a>;; <b>KEY-BITS</b>
1 <a name="L029F"></a>;; <b>KEY-3KEYS</b>
1 <a name="L0296"></a>;; <b>KEY-LINE</b>
1 <a name="L028E"></a>;; <b>KEY-SCAN</b>
1 <a name="L0284"></a>;; <b>E-DIGITS</b>
1 <a name="L026A"></a>;; <b>SYM-CODES</b>
1 <a name="L0260"></a>;; <b>CTL-CODES</b>
1 <a name="L0246"></a>;; <b>EXT-SHIFT</b>
1 <a name="L022C"></a>;; <b>E-UNSHIFT</b>
1 <a name="L0205"></a>;; <b>MAIN-KEYS</b>
1 <a name="L0095"></a>;; <b>TKN-TABLE</b>
1 <a name="L0090"></a>;; <b>SKIPS</b>
1 <a name="L007D"></a>;; <b>SKIP-OVER</b>
1 <a name="L0078"></a>;; <b>TEMP-PTR2</b>
1 <a name="L0077"></a>;; <b>TEMP-PTR1</b>
1 <a name="L0074"></a>;; <b>CH-ADD+1</b>
1 <a name="L0070"></a>;; <b>NO-RESET</b>
1 <a name="L0066"></a>;; <b>RESET</b>
1 <a name="L0055"></a>;; <b>ERROR-3</b>
1 <a name="L0053"></a>;; <b>ERROR-2</b>
1 <a name="L0048"></a>;; <b>KEY-INT</b>
1 <a name="L0038"></a>;; <b>MASK-INT</b>
1 <a name="L0030"></a>;; <b>BC-SPACES</b>
1 <a name="L0028"></a>;; <b>FP-CALC</b>
1 <a name="L0020"></a>;; <b>NEXT-CHAR</b>
1 <a name="L001C"></a>;; <b>TEST-CHAR</b>
1 <a name="L0018"></a>;; <b>GET-CHAR</b>
1 <a name="L0010"></a>;; <b>PRINT-A</b>
1 <a name="L0008"></a>;; <b>ERROR-1</b>
1 <a name="L0000"></a>;; <b>START</b>
1 <a name=""></a>;; <b>str-&-no</b>
1 <a name=""></a>;; <b>no-&-no</b>
1 <a name=""></a>;; <b>PO-T&UDG</b>
1 <a name=""></a>;; <b>K-8-&-9</b>
1 <a name=""></a>;; <b>BE-H&L-LP</b>
1 ;<font color=#339933> 180 deg. (pi) 0 -|----+----|-- 0 (0) 0 degrees</font>
1 ;<font color=#339933> ---------/----| </font>
1 ;<font color=#339933> 1 y</font>
1 ;<font color=#339933> . c b /a |</font>
1 ;<font color=#339933> tan- | \ | / | tan+</font>
1 ;<font color=#339933> tan+ |/ | \| tan-</font>
1 ;<font color=#339933> sin- | / | \ | sin-</font>
1 ;<font color=#339933> sin+ |\ | /| sin+</font>
1 ;<font color=#339933> h /y|</font>
1 ;<font color=#339933> h / |</font>
1 ;<font color=#339933> cos- | \ | / | cos+</font>
1 ;<font color=#339933> cos- | / | \ | cos+</font>
1 ;<font color=#339933> 1 /b|</font>
1 ;<font color=#339933> 1 / |</font>
1 ;<font color=#339933> . /1 |x</font>
1 ;<font color=#339933> B ---------------------/----------+-+--------\ C</font>
1 ;<font color=#339933> . c/ |</font>
1 ;<font color=#339933> <- 1 -><- 1 -> </font>
1 ;<font color=#339933> /----| </font>
1 ;<font color=#339933> . a/2 D / a E|-+ \ </font>
1 ;<font color=#339933> III -1 IV</font>
1 ;<font color=#339933> 1/ |x</font>
1 ;<font color=#339933> /a |</font>
1 ;<font color=#339933> y</font>
1 ;<font color=#339933> . /|</font>
1 ;<font color=#339933> / |</font>
1 ;<font color=#339933> . / | \ </font>
1 ;<font color=#339933> /|</font>
1 ;<font color=#339933> | \|/) | </font>
1 ;<font color=#339933> | /|\ |</font>
1 ;<font color=#339933> . / | \ </font>
1 ;<font color=#339933> (3pi/2)</font>
1 ;<font color=#339933> . / | \ </font>
1 ;<font color=#339933> |</font>
1 ;<font color=#339933> . 1 / | \ </font>
1 ;<font color=#339933> . / | \ </font>
1 ;<font color=#339933> . / |a/2\ </font>
1 ;<font color=#339933> . / | \ </font>
1 ;<font color=#339933> . / | \ </font>
1 ;<font color=#339933> . /|\ </font>
1 ;** Part 9. ARITHMETIC ROUTINES **
1 ;** Part 8. EXPRESSION EVALUATION **
1 ;** Part 7. BASIC LINE AND COMMAND INTERPRETATION **
1 ;** Part 5. SCREEN AND PRINTER HANDLING ROUTINES **
1 ;** Part 4. CASSETTE HANDLING ROUTINES **
1 ;** Part 3. LOUDSPEAKER ROUTINES **
1 ;** Part 2. KEYBOARD ROUTINES **
1 ;** Part 10. FLOATING-POINT CALCULATOR **
1 ;** Part 1. RESTART ROUTINES AND TABLES **
1 ;** An Assembly File Listing to generate a 16K ROM for the ZX Spectrum **
1 ; | BASIC | Display | Attributes | ZX Printer | System |
1 ; | ROM | File | File | Buffer | Variables |
1 ; zero, then that signifies that the stream is closed.
1 ; write and it would use less space to include the five instructions in-line.
1 ; within the class routine rather than holding the address within the table.
1 ; with the value of the next line number. It gets fetched but is discarded.
1 ; with STKEND, are updated adding BC if they are higher than the position
1 ; with ED-LOOP as the stacked return address.
1 ; will evaluate the full 11-character expression for all values where n is
1 ; will crash. - Vickers, Pitman 1984.
1 ; which may be integer of floating point and continuing into addition.
1 ; which is, at the same time, used to skip along the corresponding FN function
1 ; which is then reduced to range $00 - $31 and added to the base address
1 ; which is returned in BC, setting A to $FF, if greater than a limit supplied
1 ; which is not surprising with regard to 'K' and 'S'.
1 ; which has an infinite tangent. e.g. PRINT TAN (PI/2) evaluates as 1/0.
1 ; which are not bit-mapped but detects the ASCII 32 - 127 range.
1 ; which are never present from the keyboard.
1 ; where the error will be cancelled and the loop begin again from ED-AGAIN
1 ; where a list of class codes, separators and addresses relevant to the
1 ; when variables kick in, would serve fine as a virtual end point.
1 ; when the routine NEXT-ONE was successfully re-written to reflect this.
1 ; when the counted loop is complete the final subtraction yields the result
1 ; when loop complete continue.
1 ; when a BASIC line is checked for syntax. It is this routine that
1 ; when ENTER received rejoin other route but with no syntax check.
1 ; we've run out of memory so give a short rasp.
1 ; we now have start in DE and an end in HL.
1 ; we have, say, LIST #15, and a number must follow the separator.
1 ; we can calculate angle b as pi/2 (both angles) minus asn(x) (angle a).
1 ; we can also restore the next literal pointer from its position on the
1 ; way. Statistically it just increases the chances of trailing zeros which
1 ; was over 0
1 ; virtual line numbers. That is the destination of a GO TO, RESTORE etc. need
1 ; variable.
1 ; variable number of following data bytes that convey to the routine
1 ; variable can be detected by a call to ALPHANUM.
1 ; value containing the stream identifier. They have to swapped.
1 ; using a look-up table.
1 ; using SCANNING. The final call with the syntax flag reset is to make
1 ; uses acs(x) = pi/2 - asn(x)
1 ; used to print an unassigned control character in range 0-31d.
1 ; used during input, to clear editing area if no program exists
1 ; used 9 times
1 ; used 4 times.
1 ; used 3 times.
1 ; used 19 times
1 ; used 11 times
1 ; use the full range available.
1 ; use the floating point routines from assembly language may wish to
1 ; upwards so that -3.4 gives -3 whereas the BASIC INT function has to
1 ; upwards or the GO SUB stack downwards.
1 ; update X_PTR to the location reached by CH_ADD and jump to ED-ERROR
1 ; unless the nibble is zero as the buffer is already zero.
1 ; truncate negative numbers down so that INT -3.4 is -4.
1 ; transient state is also now transferred permanently to bit 3 of FLAGS
1 ; to their minimum configurations as at initialization and indeed this
1 ; to the temporary ones.
1 ; to the second byte of the channel.
1 ; to the loudspeaker.
1 ; to the ZX Printer. These text lines are mapped linearly so HL does
1 ; to that used for semi-tone table values.
1 ; to test if BREAK (SHIFT - SPACE) is being pressed.
1 ; to move up one line scrolling if necessary.
1 ; to mix stream altering commands and colour items.
1 ; to manipulate H to form the correct colour attribute address.
1 ; to let the interrupt routine know how to decode the next key.
1 ; to fetch two numbers by the addition, multiply and division routines.
1 ; to fetch the next line number.
1 ; to evaluate the parameters of both commands.
1 ; to denote that the contained expression is to be evaluated as an entity.
1 ; to delete these second characters.
1 ; to close the associated streams so a mechanism is provided to
1 ; to be tested.
1 ; through the motions of checking dummy dimension sizes.
1 ; through an angle of PI radians (180 degrees).
1 ; three parts: a coarse part (H register), a medium part
1 ; three instructions.
1 ; three digits of a 4-digit BASIC line printing a space if necessary.
1 ; this subroutine is called from two processes. while outputting BASIC lines
1 ; this subroutine is called from above
1 ; this should occur now. This omission leaves the stack unbalanced and while
1 ; this routine stores an integer in DE at address HL.
1 ; this routine is called with carry set and exits at a conditional return.
1 ; this routine is called once
1 ; this routine is called from chr$, scrn$ etc. to store a simple string result.
1 ; this routine collects a floating point number from the stack into the
1 ; this routine also sets flags.
1 ; this route is taken when checking syntax.
1 ; this point when the new variable types were allocated their masks and also
1 ; this must be a direct command.
1 ; this is the re-entry looping point when handling a string of literals.
1 ; this is the branch used to add normal non-control characters
1 ; this entry point is used from RUN command with BC holding zero
1 ; this entry point is called from ED-COPY
1 ; this branch is for line numbers.
1 ; this branch is also taken from ed-down.
1 ; this 'command' is ignored in runtime but has its syntax checked
1 ; they are not necessary.
1 ; these in turn are written using further strings of calculator literals so
1 ; these are meaningless it is of no concern as the limit is never checked by
1 ; therefore require surrounding braces.
1 ; thereby ending the recursion producing the correct result.
1 ; thereafter.
1 ; there are a surprising number yet to be assigned.
1 ; then when the other Spectrum has said PRINT #15; x, y
1 ; then this value 'E' or 'G' will take precedence.
1 ; then the table requires no zero end-marker. If this is not known at the
1 ; the value of variable is deleted but remains after calculator stack.
1 ; the value of MODE, maintained by KEY-INPUT, is tested and if non-zero
1 ; the two values v,l are on the calculator stack.
1 ; the two screens overlap so adjust upper screen.
1 ; the true condition - first is longer than second (SECND-LESS)
1 ; the three types of numeric variables rejoin here
1 ; the tangent of angle x is the ratio of the length of the opposite side
1 ; the tangent can be defined in terms of the previous two functions.
1 ; the system variables but apart from that it is a simple task
1 ; the system variable MEM addresses the variable's contents which, in the
1 ; the start of the buffer and the line number to 0 (B)
1 ; the square root by stacking the value .5 and continuing into the 'to-power'
1 ; the six types to be distinguished. Bits 4-0 are the reduced letter.
1 ; the second location.
1 ; the same function, either directly or indirectly ( through another function).
1 ; the running flag A, which may be $00 or $FF from a previous invocation.
1 ; the result is positive. This only applies when the signs don't match.
1 ; the program 'end-marker' then the previous line is used and if that
1 ; the previous pointer is fetched from the machine stack to H'L' where it
1 ; the position store routine
1 ; the path for non-zero digits rejoins here.
1 ; the others in print_items.
1 ; the operator character. The thirteen calculator operations $03 - $0F
1 ; the operation code has bit 7 set if result is numeric and bit 6 is
1 ; the only thing now is to consider if a slice is required.
1 ; the only limit to dimensions is memory so, for example,
1 ; the offset therein, gives the location in the following parameter table
1 ; the numbers in the series
1 ; the number of digits before the decimal point.
1 ; the number marker also appears after the arguments of a DEF FN statement
1 ; the number PI 3.14159...
1 ; the next statement of a direct command is to be considered.
1 ; the next 2 bits denote in which third of the screen the byte is.
1 ; the new less significant digit is multiplied by an increasingly smaller
1 ; the lower screen was not cleared, at the outset, so if deleting then old
1 ; the low byte is derived from both X and Y.
1 ; the loop to continue till all subscripts are checked. While doing this it
1 ; the loop branched to here with no carry
1 ; the line number and later the statement number held in BC.
1 ; the letters matched but one was string and the other numeric.
1 ; the letters match so test the type.
1 ; the lengths decreased and the branch taken back to here. If both string
1 ; the last priority was greater or equal this one.
1 ; the last 3 bits denote in which of the 8 scan lines within a third
1 ; the keyboard. Others like the upper screen 'S' are output
1 ; the keyboard. A channel can have an input and output route
1 ; the jump was to here with INPUT LINE only
1 ; the jump was to here when using INPUT LINE.
1 ; the jump was to here when ALPHA found more items while looking for
1 ; the jump was to here if the variable already existed.
1 ; the jump was to here if S_TOP was greater than E_PPC
1 ; the jump was here with all other matches HL points to first var char.
1 ; the jump was here with a new string variable.
1 ; the jump was here when a long name matched and HL pointing to last character
1 ; the jump was here if no match and more bitmaps to test.
1 ; the juggling act
1 ; the inverse tangent function with the result in radians.
1 ; the inverse cosine function with the result in radians.
1 ; the integer or floating point form as succinctly as is possible.
1 ; the high byte is derived from Y only.
1 ; the first 3 bits are always 010
1 ; the false condition.
1 ; the exit point from line printing continues here.
1 ; the error path rejoins here.
1 ; the end of a statement should have been reached and all preceding
1 ; the division. Had it been done first then either present code or that used
1 ; the dimension counting loop which is entered at mid-point.
1 ; the data entry itself contains an offset from CHANS to the address of the
1 ; the current line number and current statement + 1
1 ; the correct value for the attribute file and it is only necessary
1 ; the control and two following characters are ignored and processing
1 ; the continuation here is for the next variable unless the supplied
1 ; the calculator stack. The presence of the 'THEN' separator has also been
1 ; the calculator stack. It can't be popped off.
1 ; the calculator stack.
1 ; the calculate routine is called at this point by the series generator...
1 ; the byte is located. There are 24 discrete values.
1 ; the branch was to here if higher than space.
1 ; the branch was here with string and numeric arrays in runtime.
1 ; the branch was here with simple literals.
1 ; the branch was here with quadrants II (0 to 1) and III (1 to 0).
1 ; the branch was here with matching letter and numeric/string type.
1 ; the branch was here with just LIST #3 etc.
1 ; the branch was here with flash and bright
1 ; the branch was here with an array of strings.
1 ; the branch was here with a match
1 ; the branch was here with a large positive integer > 65535 e.g. 123456789
1 ; the branch was here with LIST
1 ; the branch was here with INK/PAPER and carry set for INK.
1 ; the branch was here when checking syntax
1 ; the branch was here when all arguments passed.
1 ; the branch was here when a stacked priority/operator had higher priority
1 ; the branch was here when 2nd string not null and low byte of first is yet
1 ; the branch was here when 'int x' was found to be zero as in say 0.5.
1 ; the branch was here to handle bits in DE with 8 or 16 in B if small int
1 ; the branch was here if syntax has passed test.
1 ; the branch was here if checking syntax only.
1 ; the branch was here from L-DELETE$ if an existing simple string.
1 ; the branch was here for string subscripts when the number of subscripts
1 ; the branch was here for E-format printing e.g. 123456789 => 1.2345679e+8
1 ; the branch is to here in runtime after a successful operation.
1 ; the assignment.
1 ; the argument to the sine and cosine functions.
1 ; the accumulator holds the exponent.
1 ; the OPEN-P routine would have refused to attach a stream if another
1 ; the KEYS table for chr$ 6 which also pointed here.
1 ; the CHANS area to the second byte of the stream's channel. If BC holds
1 ; the BASIC line when it is fetched to the edit buffer by OUT_LINE.
1 ; the B register, which counts dimensions is set to zero (256) to allow
1 ; the B register and the operation code, calculator literal in the C register.
1 ; the 'USR' function is special in that it is overloaded to give two types
1 ; that to implement it in-line would make the code hard to follow.
1 ; that only leaves 0-5, the flash bright inverse switches.
1 ; that is '+', '=', '>', '<', '<=', '>=' or '<>'.
1 ; that incorporates a memory check.
1 ; that causes no problems with a simple PRINT statement, it will if str$ is
1 ; that calls this one will also stack any of its string results so this
1 ; than the current one.
1 ; text from a previous print may follow this line and requires blanking.
1 ; tabstops. The routine is only reached via the control character table.
1 ; table $C3 - $CF to obtain the priority for the respective operation.
1 ; system variables.
1 ; system is remarkably robust.
1 ; syntax of both string and numeric arrays definitions except that bit 6 of C
1 ; syntax is in order.
1 ; superfluous.
1 ; success.
1 ; subtracting angle x from pi/2.
1 ; subsequent RST $10 instructions take the appropriate action
1 ; strs-neql x$<>y$ 13 00001011 dec 00001010 00000101 ---- x$y$ 0 !or >0? NOT
1 ; strs-eql x$=y$ 16 00001110 - 00001110 00000111 ---- x$y$ 0 !or >0? ---
1 ; strings or a 3-dimensional array of characters.
1 ; strings and arrays rejoin here
1 ; stream which is passed on the calculator stack. It returns with HL
1 ; stream was attached.
1 ; str-less x$<y$ 15 00001101 - 00001101 10000110c swap y$x$ 0 !or >0? ---
1 ; str-l-eql x$<=y$ 11 00001001 dec 00001000 00000100 ---- x$y$ 0 !or >0? NOT
1 ; str-grtr x$>y$ 14 00001100 - 00001100 00000110 ---- x$y$ 0 !or >0? ---
1 ; str-gr-eql x$>=y$ 12 00001010 dec 00001001 10000100c swap y$x$ 0 !or >0? NOT
1 ; store any integer as positive.
1 ; statements at the same time. Syntax of both has been checked previously
1 ; statement number which limits the length of the message text to twenty
1 ; start of the next routine to calculate the length to reclaim.
1 ; start of loop.
1 ; stack to the BC register.
1 ; stack that is not a regular constant this routine is called with a
1 ; space(out_char), 2(out_code), 0(out_char) final number always out-code.
1 ; something bigger. In any case it would have to be created after
1 ; slice being accepted as part of the DIM command.
1 ; skipping spaces and colour control codes. It is similar to NEXT-CHAR
1 ; single operation jumps back to here
1 ; single offset byte to the routine that services that code.
1 ; single character numerics rejoin here with %00000000 in mask.
1 ; since there is no leading zero put one on the calculator stack.
1 ; simplistic approach to all other functions and assume that they have
1 ; simpler as both colour controls and their parameters are less than space.
1 ; sign depending on the quadrant rules.
1 ; should also be unacceptable then zero is used as it must be a direct
1 ; set if operand is numeric. so
1 ; set if 'THEN' or ':' was encountered as a main character and reset otherwise.
1 ; second character. Strings 'RB', 'RT' perhaps or a drive/station number.
1 ; scrolling is required, prompting the user if necessary.
1 ; says that invalid values will be trapped.
1 ; runtime, by LOOK-VARS in the variables area.
1 ; runtime numeric arrays path rejoins here.
1 ; runtime evaluation.
1 ; routines to stack a number expressed in exponent format.
1 ; routine. With more space available the much faster Newton-Raphson method
1 ; routine to set flags for upper screen channel.
1 ; routine to set flags for lower screen/keyboard channel.
1 ; routine could have been relied on to perform that task.
1 ; right-angled triangles. Triangles have some special properties -
1 ; returning with carry set if so.
1 ; returning with carry reset if so.
1 ; return here in runtime.
1 ; reset the system channel input and output addresses to normal.
1 ; reset MEM to its usual place in the systems variable area should it
1 ; resembling that of the desired sine value.
1 ; requires checking.
1 ; required. On entry the A register holds the literal ANDed with 1F.
1 ; required for these are allocated. Spectrum programmers who wish to
1 ; reprinted. If no error then the re-iteration is to ED-LOOP below when
1 ; representing a power of two, x is multiplied or divided by the
1 ; remainders become null at the same time, then an exact match exists.
1 ; registers HL and DE only point to somewhere meaningful in runtime so
1 ; register HL addresses start of string in variables area.
1 ; reduced argument from the value 1 (a reduced right-angle).
1 ; ready to be added.
1 ; re-attach them. When the re-attachment is no longer required, then
1 ; range checking will be performed.
1 ; radians.
1 ; quadrant III ranges -2 to -1.
1 ; quadrant II ranges +1 to +2.
1 ; quadrant I (0 to +1) and quadrant IV (-1 to 0) are now correct.
1 ; purposes.
1 ; provided by the user and not the operating system.
1 ; provide for flexibility in this respect.
1 ; program.
1 ; program area, variables area, workspace etc..
1 ; producing an error if either is out of range.
1 ; proceed with multi-dimensioned string arrays in runtime.
1 ; proceed with a negative result.
1 ; proceed when the sync at the end of the lead-in is found.
1 ; proceed when terminating quote encountered.
1 ; proceed to check string arrays during syntax.
1 ; proceed if syntax passed.
1 ; proceed if checking syntax of an array?
1 ; print to printer or update the relevant system variables.
1 ; print items. An early return can be made from within the loop
1 ; print item e.g. PRINT PAPER 6; "Hi". In the latter case, the looping for
1 ; previous line or edit line.
1 ; preserve the original value of DEFADD and not assume that it is zero.
1 ; precise 'No Room for line' report.
1 ; possible.
1 ; position at line C, column B. It is unable to detect the mosaic characters
1 ; position at each jump in DE. Once it arrives at the cursor then the next
1 ; points to the stack location holding address ED_ERROR.
1 ; points to STKEND.
1 ; pointing to this system variable and BC holding a displacement from
1 ; pointing to the 'ninth' line and H needs to be decremented before or after
1 ; point to the location before the supplied line number or first line
1 ; placed near the start of the program as we shall see.
1 ; performs another very important function also.
1 ; parameters, it is entered at the second entry point so as not to disturb
1 ; over a page boundary.
1 ; outset then a zero end-marker is required and carry is set to signal
1 ; otherwise the cumbersome 4 instructions in the middle could be replaced by
1 ; otherwise as follows.
1 ; other than from above, this routine is called from STK-VAR to stack
1 ; or the input buffer to the lower screen so a direct call to $09F4 can
1 ; or the column for printer.
1 ; or screen, copying a BASIC line to the edit buffer and printing the
1 ; or parsing, of each statement.
1 ; or memory addresses and also array subscripts and tab arguments.
1 ; or from above.
1 ; or a continuation from above if dealing with a new sequential line.
1 ; or 'P', which are all that are supported by this ROM, but if that last
1 ; only and the input routine usually points to a report message.
1 ; one argument.
1 ; on the permutations possible.
1 ; on the calculator stack.
1 ; on the calculator stack multiplying the previous value by ten each time
1 ; on entry there is a value x on the calculator stack and an exponent of ten
1 ; off the stack breaking out of the above seemingly endless loop.
1 ; of which indicate the type of variable.
1 ; of this table to give the address of an offset which, when added to
1 ; of the strings. For each successful match, the pointers are incremented and
1 ; of the start of a screen character line which is supplied in B.
1 ; of the computer. However the stream can be altered in range 0 - 15.
1 ; of the DEF FN statement. Each of the arguments of the FN function is
1 ; of result.
1 ; of replacing it and the manual became unfeasible.
1 ; of length zero or 1.
1 ; of breaking out of such recursion.
1 ; of a tight loop that considers sequences of positional and print items
1 ; of PR_CC_hi.
1 ; numeric in operator look up they must be changed to string equivalents.
1 ; numbers. It returns 10*A +C in registers C and A
1 ; numbers up. It also handles BIN format numbers.
1 ; numbers in full, five byte form and stack them in a similar manner
1 ; number supplied in HL, or failing that the address of the following line
1 ; null string as the final addend.
1 ; now use the calculator to perform the single operation - operand is on
1 ; now test if found variable is a simple variable uninitialized by a FOR.
1 ; now produce prompt.
1 ; now multiply exponent by log to the base 10 of two.
1 ; now enter a loop?
1 ; now enter a loop.
1 ; now enter a loop to parse each of the integers in the list.
1 ; now enter a loop to handle each pixel line.
1 ; now enter a loop
1 ; now delete int x from calculator stack and fetch fractional part.
1 ; now delete but leave HL pointing at integer
1 ; now deal with long-named variables
1 ; now deal with colour controls - 16-23 ink, 24-31 paper
1 ; now consider first character which has bit 6 set
1 ; now consider digits of exponent.
1 ; now consider P-FLAG.
1 ; now check that there were no more subscripts in the BASIC line.
1 ; now calculate space required for array variable
1 ; now balance the calculator stack by deleting it
1 ; now backtrack CH_ADD to set up for slicing routine.
1 ; now as in print +2. This should not be confused with the operator '+'.
1 ; note if used from str$ then other values may be on the calculator stack.
1 ; not used in this ROM.
1 ; not possible to specify an end line.
1 ; not position the cursor between control codes and their parameters.
1 ; not need to be adjusted at the end of each line.
1 ; not exist. It could be a point before or after an actual line number.
1 ; not documented properly
1 ; nos-neql x<>y 0B 00000011 dec 00000010 00000001 ---- x-y ? NOT --- NOT
1 ; nos-eql x=y 0E 00000110 - 00000110 00000011 ---- x-y ? NOT --- ---
1 ; normal place after the program. Preference will be given to the former.
1 ; normal channels.
1 ; normal 'Out of Memory' report to be augmented to the more
1 ; no-less x<y 0D 00000101 - 00000101 10000010c swap y-x ? --- >0? ---
1 ; no-l-eql x<=y 09 00000001 dec 00000000 00000000 ---- x-y ? --- >0? NOT
1 ; no-grtr x>y 0C 00000100 - 00000100 00000010 ---- x-y ? --- >0? ---
1 ; no-gr-eql x>=y 0A 00000010 dec 00000001 10000000c swap y-x ? --- >0? NOT
1 ; no loop is possible so execution continues after the matching 'NEXT'
1 ; must enable them to pass the next step. We also jumped to here if the
1 ; must be zero itself
1 ; must be a string array or a slice in workspace.
1 ; multiple items is within the PR-ITEM routine.
1 ; mult, re-stack and negate to fetch an integer from address HL.
1 ; much of the arithmetic found in BASIC lines can be done using numbers
1 ; more complex to start a remarkable juggling act.
1 ; moment. They will be used every time the corresponding function is
1 ; mode and moves it to the right.
1 ; message number held in A. DE holds the address of the table.
1 ; marker '?' or from the next routine to print a flashing cursor e.g. 'L'.
1 ; machine stack.
1 ; machine code routines cannot be written in the first 16K of RAM as
1 ; locations following the location addressed by DE.
1 ; located where these and other sequential command addresses are not split
1 ; literal to perform an integer multiplication in preference to
1 ; literal Test No sub 8 ExOrNot 1st RRCA exch sub ? End-Tests
1 ; line number was erroneously over 16383. see RESTORE command.
1 ; line number pointed to by HL.
1 ; line number and statement to the equivalent "NEW VALUE" system variables
1 ; limit value and also for the intervening separator.
1 ; legitimate leftmost position is in DE.
1 ; leaving the naked parameter (0-7) which appears as a '?' except in the
1 ; leaving long name variables.
1 ; leads to a double storing of the result in this case.
1 ; latter two cases that it has any relevance and in the last case it
1 ; latter case, have had the step, possibly negative, added to the value.
1 ; last value to form a new last value.
1 ; keyboard was not being used.
1 ; keyboard input is assigned. On the first occasion syntax is checked
1 ; just a colourful novelty. One remarkable feature is that in all previous
1 ; jumping one, two, or three characters as necessary saving the original
1 ; iteration and from the NEXT command to test for all subsequent iterations.
1 ; items separated by a newline '.
1 ; it was a string. White-space may be present but syntax has been checked.
1 ; it was $10 - $15 so step over a colour code.
1 ; it seems unusual to store the low byte first but it is just as easy either
1 ; it now remains to update the STRMS variable.
1 ; it is shared with the ULA which has precedence over the Z80 chip.
1 ; it is invoked. The machine stack is below the GOSUB stack. Both grow
1 ; it is either ink 9 or paper 9 (contrasting)
1 ; it is binary so adjust pointers.
1 ; it is also the OUTPUT service routine for system channel 'R'.
1 ; is used to restore the twos complement number to normal in DE and a sign
1 ; is used and rectified using the test result stored in mem-0 by 'get-argt'
1 ; is that it can be called indiscriminately when merging a line or a
1 ; is tested before being set to the implied state. Negative numbers are twos
1 ; is reset so both are checked as numeric arrays. This ruse avoids a terminal
1 ; is reading dimension sizes from some arbitrary area of memory. Although
1 ; is rather simple e.g. MOVE "M1","M2"
1 ; is not required and H is set to $FF. When checking optional string slice
1 ; is not available from within the calculator.
1 ; is made to produce an error report here.
1 ; is in use.
1 ; is an advantage elsewhere in saving ROM code.
1 ; is a dummy entry. The last, which begins with $7F, the Spectrum
1 ; invalid colour or position control code has left the output routine addressing
1 ; into the correct position to leave the other 7 pixels unaffected.
1 ; into common code.
1 ; int-exp during syntax checking.
1 ; instruction to save a few clock-cycles.
1 ; instruction could be replaced with a JR instruction, this applies to the
1 ; instead of the expected result "20.5".
1 ; instead of $3F. This leads to commands with operands greater than 32767
1 ; instance, appears to move to the left.
1 ; inserts, during syntax checking, the invisible floating point numbers
1 ; input-ad rejoins here also.
1 ; input workspace is required to be printed to the lower screen.
1 ; input is arriving from the keyboard.
1 ; input buffer or edit buffer to the lower screen. It is only in the
1 ; input #15; i ; j would treat the comma control as a newline and the
1 ; ink 10 etc. is not allowed.
1 ; inclusion of the line in the BASIC program area.
1 ; in workspace by ADD-CHAR.
1 ; in variables area.
1 ; in this form using the Z80's 16 bit register operation ADD.
1 ; in the program area or the next variable in the variables area.
1 ; in the program area before searching in the normal variables area.
1 ; in the current statement.
1 ; in the LINE-ADDR routine as it will pass the program/variables end-marker
1 ; in the BC register or zero if no digits exist before commands.
1 ; in the BASIC line was one less than in variable definition.
1 ; in runtime the variable definition indicates a comma should appear here
1 ; in run-time. It is also called once from PRINT-POSN.
1 ; in line with the desired sine value and afterwards it can launch straight
1 ; in fact since 'tab' and 'at' cannot be entered the next section seems
1 ; in all situations - see shortly.
1 ; in a very similar manner to GO TO but
1 ; in X_PTR while CH_ADD is used to read the second list.
1 ; in HL. It is used to check array subscripts, parameters of a string slice
1 ; in HL.
1 ; in A. The required value is x + 10 ^ A
1 ; if, as seems possible, they existed.
1 ; if we pass to next then there are no system errors
1 ; if variables exist, then the first character of any variable name.
1 ; if using another input channel rejoin here.
1 ; if this is lower priority yet has string then must be a comparison.
1 ; if the end of a print sequence is reached.
1 ; if original number was say .999 then this integer component is zero.
1 ; if nine digits complete then the last one is rounded up as the number will
1 ; if neither, then an expression is required so rejoin runtime loop ??
1 ; if it is known that the character is in the table e.g. for priorities,
1 ; if it is a system channel then it can re-attached.
1 ; if entering here then all class routines are entered with zero reset.
1 ; if checking syntax the letter is not returned
1 ; if another character was found then raise an error.
1 ; if B counts down to zero then we've rounded right back as in 999999995.
1 ; however since the leftmost bit of the mantissa is always set then it can
1 ; how long the computer has been switched on.
1 ; holds a subtraction value -1000, -100 or -10.
1 ; held in short form in a table of constants. In fact only 5 constants are
1 ; held in C, returning the address of the following offset byte.
1 ; have bits 6 and 7 set to signify a numeric result.
1 ; have been relocated to a FOR-NEXT variable. The main entry point
1 ; handler and an input stream set up to supply characters.
1 ; h$(16) indicates the single character at position 16.
1 ; greater than zero but just the 11th character, "0", when n drops to zero
1 ; giving an 'Out of Screen' error.
1 ; functions that can have more than one argument and therefore require
1 ; functions e.g. TAN are written using other functions and literals and
1 ; functions SCREEN$, ATTR and POINT that have two fixed parameters and
1 ; from the keyboard. If inputting from a tape device or network then
1 ; from the CLASS routines.
1 ; from computation
1 ; from OUT-LINE - HL addresses line number.
1 ; from LIST-ALL to output the line to current channel
1 ; free location after dynamic memory must be the last encountered.
1 ; four operators and eight functions. e.g. $A8 is the token 'FN'.
1 ; four bytes of code, but a call instruction only uses 3 bytes of code.
1 ; found could be in the argument list to the left of the '=' or in the
1 ; forward to the next statement in runtime.
1 ; for which to wait. PAUSE 50 pauses for about a second.
1 ; for the print flag the permanent values are odd bits, temporary even bits.
1 ; for the other 4 cases the two values on the calculator stack are exchanged.
1 ; for that purpose.
1 ; for positive numbers. The truncate literal truncates negative numbers
1 ; for integer numbers an entire byte denotes the sign.
1 ; for floating point numbers a single bit denotes the sign.
1 ; for example SIN X.
1 ; follow the AT ( in PRINT AT, INPUT AT).
1 ; flag setting routines below it.
1 ; first make exponent +1 +16d (bit 7 of the exponent is set if positive)
1 ; first convert a one-byte signed integer to its five byte form.
1 ; finally form the pixel position in A.
1 ; few extra bytes of code. As usual, anything to do with CHARS is weird.
1 ; factor (1/100, 1/1000, 1/10000 ... ) before being added to the previous
1 ; expressions. These cannot occur in a program area so this routine is
1 ; expressions before a terminal ')', although, as above, it will still go
1 ; expression to the right of the DEF FN '=' is evaluated by SCANNING and for
1 ; expression or by a recursive call to SCANNING for the first character of
1 ; expression of the same type can be substituted ad infinitum.
1 ; expression may not be used when a number is expected.
1 ; exponent is picked up in A and the location made zero. Then the sign bit
1 ; exceptions are val, val$ and str$.
1 ; except the latter has to deal with AT and TAB characters in string
1 ; exact match and x$>y$ rejoin here
1 ; even if you are still saving up for a ZX Printer or have moved onto
1 ; evaluated in runtime.
1 ; evaluated by SCANNING and placed in the hidden locations. Then the
1 ; error report 'Statement Lost' is given instead of 'OK'.
1 ; entry in the table.
1 ; entry for chr$ 6 with offset to ed-symbol.
1 ; end of functions accessed from scanning functions table.
1 ; end of dynamic memory to an adequate area within the system variables area.
1 ; else there has been 8-bit overflow
1 ; else the angle lies in quadrant I or IV and value Y is already correct.
1 ; else report the error.
1 ; else read a key from the keyboard.
1 ; else more subscripts in BASIC line than the variable definition.
1 ; else byte is just a byte count and exponent comes next.
1 ; else angle is within quadrant II (-1 to 0)
1 ; else all data in this statement has been read so look for next DATA token
1 ; either a continuation of above or from ED-CONTR with ED-LOOP on stack.
1 ; editing and input mode.
1 ; edit line is missing. OUT-LINE will scroll automatically.
1 ; edit line end-marker ($80) if from LINE-RUN.
1 ; edit buffer and not workspace.
1 ; early if checking syntax.
1 ; each of the 9 nibbles in mem 4 is placed into ten bytes in mem-3 and mem 4
1 ; e.g. the arccosine of a known x value will give the required angle b in
1 ; e.g. the Sinclair Interface 1 ROM, to handle these commands.
1 ; e.g. READ a, b$, c$(1000 TO 3000)
1 ; e.g. PRINT 2 * (VAL "2+2" + TAN 3)
1 ; e.g. PLOT PAPER 0; 128,88 ; two coordinates preceded by optional
1 ; e.g. PLOT INK 2; PAPER 8; 128,88
1 ; e.g. NEXT i
1 ; e.g. IF score>100 THEN PRINT "You Win"
1 ; e.g. FOR i = 0 TO 1 STEP 0.1
1 ; e.g. DIM a(2,3,4,7): DIM a$(32) : DIM b$(20,2,768) : DIM c$(20000)
1 ; e.g. DEF FN r$(a$,a) = a$(a TO )
1 ; e.g. DEF FN a(n) = VAL "n+FN a(n-1)+0" ((n<1) * 10 + 1 TO )
1 ; e.g. DEF FN s $ ( x ) = b $ ( TO x ) : REM exaggerated
1 ; e.g. DATA 1, 2, "text", score-1, a$(location, room, object), FN r(49),
1 ; e.g. "1000 LET a=1" is 8 characters.
1 ; e.g. "B Integer out of range, 1000:127"
1 ; e.g. 0 OR 0 returns 0.
1 ; during the D-NO-LOOP working downwards from position before start of data.
1 ; during line-entry.
1 ; during both, this routine will pass over an invisible number indicator
1 ; durations and coordinates.
1 ; duration of low = 118 + 1024*H + 16*(L>>2) + 4*(L&0x3)
1 ; duration of hi = 118 + 1024*H + 16*(L>>2) + 4*(L&0x3)
1 ; dummy line number so that zero will be printed in the report.
1 ; downwards, the machine stack by two bytes, the GOSUB stack by 3 bytes.
1 ; does not give the 'Nonsense..' error if the three variables exist.
1 ; divided by the length of the adjacent side. As the opposite length can
1 ; displaying an error.
1 ; dimensions(1) but since we have yet to double allow for two
1 ; dimensions of the variable match the number of subscripts supplied in the
1 ; dimensional array of zeros. String arrays are initialized to spaces.
1 ; destination variable for an assignment.
1 ; designed to work with any output device.
1 ; depending within which quadrant the angle lies, with the periodicity
1 ; deleting the last value.
1 ; deletes the last value from the calculator stack.
1 ; definition of another defined function (though not itself).
1 ; dec (iy+$2d) - three bytes instead of six.
1 ; cutting off their feet or stretching them so they fitted the bed perfectly.
1 ; cursor. If control characters are present these are deleted first
1 ; cursor line value which would enable the line cursor to be suppressed
1 ; currently being evaluated by recursive calls to SCANNING, then we have to
1 ; current channel when it has been temporarily altered.
1 ; credit Tony Stratton, 1982.
1 ; credit Stephen Kelly and others, 1982.
1 ; credit John Elliott.
1 ; crash the machine when supplied with an inappropriate virtual line number.
1 ; could have been used as on the Jupiter Ace.
1 ; corresponding power of ten.
1 ; copy. This particularly applies to 16K Spectrums as time-critical
1 ; controlled by the main ROM.
1 ; control would skip to input j.
1 ; contribute to the waveform timing as follows:
1 ; continues as if a carriage return had been received.
1 ; continue with small positive integer components in range 0 - 65535
1 ; continue with numeric comparisons.
1 ; continue with automatic listings if the screen is full and the current
1 ; continue if subscripts matched the numeric array.
1 ; continue if one of the upper-case letters was found.
1 ; continue if both were small integers.
1 ; continue if a match of all eight bytes was found
1 ; continue here with valid starting point from above or good estimate
1 ; continue here with .1, 42, 3.14, 5., 2.3 E -4
1 ; continue here if using the keyboard.
1 ; continue here if using lower display - A holds line number.
1 ; continue here if stream was open. Note that the offset is from CHANS
1 ; continue here if not an automatic listing.
1 ; continue here if checking syntax.
1 ; continue here if an automatic listing required.
1 ; continue for a new variable. DEST points to start in BASIC line.
1 ; continue as must be a direct command.
1 ; containing $0001 or more likely there would be an exit within the routine.
1 ; compound literals have the following format.
1 ; complemented.
1 ; comments apply to that situation.
1 ; commands when the Spectrum is expecting a number or a string then an
1 ; command. The program end-marker is the variables end-marker $80, or
1 ; command itself.
1 ; command exists.
1 ; comma-separated expressions.
1 ; colour value in A, mask in B.
1 ; closing these streams resets them as at initialization.
1 ; clears text lines at bottom of display.
1 ; clears 24 lines of the display and resets the relevant system variables.
1 ; class-0A e.g. ERASE "????" ; a string expression must follow.
1 ; class-08 e.g. POKE 65535,2 ; two numeric expressions separated by comma
1 ; class-07 e.g. PAPER 6 ; a single class for a collection of
1 ; class-05 e.g. PRINT ; variable syntax checked by routine
1 ; class-04 e.g. FOR i ; a single character variable must follow
1 ; class-03 e.g. RUN or RUN 200 ; optional operand
1 ; class-02 e.g. LET a = 1 + 1 ; an expression must follow
1 ; class-01 e.g. LET A = 2*3 ; a variable is reqd
1 ; class-00 e.g. CONTINUE ; no operand
1 ; class routine and the final part (,z) within the command.
1 ; class 07
1 ; chr$14 would have the same functionality.
1 ; checked or if the program is being run. To test the flag inline would use
1 ; checked and CH-ADD points to the command after THEN.
1 ; check for newline.
1 ; characters.
1 ; character for copyright symbol, is placed here for convenience
1 ; character Procrustes in Greek legend who made travellers sleep in his bed,
1 ; channels.
1 ; channel was a microdrive file, network channel etc. then
1 ; channel connected to each other:-
1 ; channel 'S' the current channel when not checking syntax.
1 ; case of chr$ 6 which is the comma control character. It is not mandatory
1 ; calculator. The correct priority for the operation has to be placed in
1 ; calculator stack to the accumulator and is used for colours, streams,
1 ; calculator stack as a default value in runtime.
1 ; calculate the space required for multi-dimensional arrays.
1 ; bytes are always blank so they are omitted in the following steps
1 ; by using the last part of GO TO and exits indirectly to STMT-RET.
1 ; by inserting a 'DEFB 02 delete' at <A href="#L2E25">L2E25</a>, and maintain main addresses.
1 ; by deleting lines. If the stack was in its normal place then a situation
1 ; but without the powerful mechanisms set up in this ROM.
1 ; but the Interface 1 programmers relaxed this allowing ';' as an
1 ; but proceed to search argument list of defined function first if not empty.
1 ; but it never will be as we advanced past long-named variables earlier.
1 ; but in runtime the number of subscripts are at least the same as dims
1 ; but in runtime search for the variable.
1 ; but if they match check that this is also last letter in prog area
1 ; but if the zero is a significant digit e.g. 10 then include in digit totals.
1 ; but if no match i.e. nested FOR/NEXT loops then continue search.
1 ; but if just an isolated quote then that terminates the string.
1 ; but for larger integers there could be nine leading digits.
1 ; but as long as we're editing lines or inputting from the keyboard, then
1 ; but a slice of a simple string can itself be sliced.
1 ; builders.
1 ; branch here in runtime.
1 ; braces. By eliminating and dealing with these now it can later take a
1 ; both strings have at least one character left.
1 ; both paper and ink rejoin here
1 ; both numeric and string paths converge here.
1 ; bits 6-5 the subgroup 0-3.
1 ; bits 4-0 the embedded parameter $00 - $1F.
1 ; bits 0-3 of the character.
1 ; bit 7 set indicates compound.
1 ; bit 7 set - activate stylus.
1 ; bit 7 low - deactivate stylus.
1 ; bit 2 set - stops printer.
1 ; bit 2 reset - starts printer
1 ; bit 1 set - slows printer.
1 ; bit 1 reset - normal speed.
1 ; being used in an expression e.g. "2" + STR$ 0.5 gives the result "0.5"
1 ; being evaluated.
1 ; being considered as having been run from the editing area and the
1 ; being checked so the entry point could have been at the second CALL
1 ; beginning with BIN, '.' or a digit.
1 ; before jumping forward to OPEN-END with the displacement value in E
1 ; before finally resetting the output address back to PRINT-OUT.
1 ; before adding in the new digit to form a last value on calculator stack.
1 ; been reached then zero is used as the default.
1 ; been found using LINE-ADDR, and it is entered at LINE-NO. If it encounters
1 ; be used, even though out-line outputs to other streams.
1 ; be used to denote the sign of the mantissa and put back when needed by the
1 ; be used for integers and larger (or fractional) numbers.
1 ; be printed using E-format notation
1 ; be extracted without raising an error and that memory can be reclaimed
1 ; be entered or re-entered into the Program area and the syntax
1 ; be cleared when COPY is used and the screen/printer position may be set to
1 ; be calculates using sin(x) and the adjacent length using cos(x) then
1 ; back on the screen though the colours may change.
1 ; b$ () () () () () () (2 TO 10) (2 TO 9) (3) is the same as b$(5)
1 ; autostart a program that has been saved with a line higher than 16383.
1 ; at this point any optional arguments have had their syntax checked.
1 ; at the start of PO-ATTR could have been used.
1 ; at the beginning we wouldn't have to alter which bit we test.
1 ; at most 9 digits for 32-bit number will have been loaded with digits
1 ; associated with it in which case it is bi-directional like
1 ; associated stream-opening routine in this ROM.
1 ; assignments e.g. LET a = 1 : LET h$ = "hat".
1 ; as you can now, so one assumes that if PR_CC_hi was non-zero then
1 ; as the calculator too is calling itself.
1 ; as is the preceding comma and space.
1 ; arises whereby the Spectrum becomes locked with no means of reclaiming space.
1 ; area depending on FLAGX.
1 ; are placed on the GO SUB stack as a RETURN point.
1 ; approximation and it would be best to update E_PPC with the true
1 ; approximate free memory with PRINT 65536 - USR 7962.
1 ; appears in the lower screen.
1 ; any variables encountered, a search is made in the DEF FN variable list
1 ; any sub-expression. It eliminates functions that have no argument or
1 ; answer is zero. If, as in this case, the carry is set then that denotes that
1 ; another level of magical recursion joins the juggling act for a while
1 ; another four bytes are required for letter(1), total length(2), number of
1 ; and would avoid coming here.
1 ; and while searching statements within a BASIC line.
1 ; and to clear editing area prior to copying the edit line to it.
1 ; and this one is interpreting input #15; a$.
1 ; and then lose control of what it is looking for - variable or line number.
1 ; and the largest angle in this case is a right-angle (pi/2 radians), then
1 ; and the five bytes floating-point number that follows it.
1 ; and the first 8 locations all hold $0A.
1 ; and the command is re-computed from the low-byte of the parameter address.
1 ; and the arguments of the DIM command. In the latter case, the limit check
1 ; and the address of the previous line in DE.
1 ; and tan are directly, or indirectly, derived.
1 ; and statement.
1 ; and runtime mode. This routine is called often to allow a routine to return
1 ; and rejoin here from above if stream was closed.
1 ; and perhaps a modified value in BC. The strange pathing does seem to
1 ; and over switches off). With both switches on, the byte is simply put
1 ; and may mask old 5-byte string parameters.
1 ; and is used to fetch command and function arguments involving line numbers
1 ; and is identified to the system by a single letter e.g. 'K' for
1 ; and integer in D'E', 6 nibbles will accommodate 065535 but routine does
1 ; and hidden locations have been created immediately after each argument
1 ; and from the routine CL-SCROLL, once, to scroll part of the display.
1 ; and from ED-EDIT to 'sprint' the line to the edit buffer.
1 ; and distinguished by bit 5 of FLAGX.
1 ; and continue with integer in range 0 - 255.
1 ; and continue to set up the next following line and then consider this new one.
1 ; and continue to print the now positive number.
1 ; and also from INPUT.
1 ; and all but one of the ROM routines can handle a buffer in that position.
1 ; and acs are directly, or indirectly, derived.
1 ; and -1 is 00000000 11111111 11111111 11111111 00000000
1 ; and 'chr$'.
1 ; an optional numeric expression e.g. RUN. If the end of statement has
1 ; an expression of unlimited complexity.
1 ; an array of numbers.
1 ; an angle of, say, 3*PI radians (540 degrees) then the net effect is to turn
1 ; although only the first pass is shown it can be seen that for each set bit
1 ; although only the first pass is shown it can be seen that at each pass
1 ; alternative for their channels creating a confusing mixture of
1 ; alter the system variable MEM to point to 160 bytes of RAM to have
1 ; also from the variables area end-marker $80.
1 ; allowable syntax as it is this ROM which opens or re-opens the
1 ; all the rest 'cos' through 'chr$' give a numeric result except 'str$'
1 ; all numbers begin with a digit and that the presence of a number or
1 ; after the numeric expression. During runtime it just picks these
1 ; after temporary relocation during line entry and also from ERROR-3
1 ; advance CH_ADD to a position after command and test if it is a command.
1 ; adjust downwards the pointers within dynamic memory.
1 ; addresses one of the numbers of the series following the series literal.
1 ; addressed by HL with leading spaces if necessary.
1 ; address within the BASIC system.
1 ; address places after the simple literals in the address table.
1 ; address in T_ADDR_lo. Note therefore that the syntax table has to be
1 ; address for screens or printer based on the line/column for screens
1 ; addition and you might like to add the numbers above to prove that the
1 ; accumulator returning carry set if not in range 0 - 255.
1 ; above. The position of the error will be apparent when the lower screen is
1 ; above, which is useful if you wish to correct the unbalanced stack error
1 ; above will be undone when the channel flags are reset during STR$.
1 ; a$(257 TO) indicates all except the first 256 characters.
1 ; a$(19000 TO 19999) indicates the thousand characters at position 19000.
1 ; a$(1,1,1) will return a single character.
1 ; a$(1,1) will return a 10-character string as will a$(1,1,1 TO 10)
1 ; a$(1,1) (1 TO 6) is the same as a$(1,1,1 TO 6)
1 ; a$() and a$( TO ) indicate the entire string although just a$ would do
1 ; a$( TO 32) indicates the first 32 characters.
1 ; a variable name.
1 ; a unary calculator literal but this will not work as the accumulator
1 ; a substring can appear to the left of the equals sign.
1 ; a string comparison or operation.
1 ; a statement is found while parsing a line.
1 ; a slice.
1 ; a runtime numeric array subscript.
1 ; a pseudo Z80 instruction CALL (HL). The ROM uses the instruction above.
1 ; a numeric result.
1 ; a minimal size of 1, after use, to free up memory.
1 ; a match has been found so seven more to test.
1 ; a loop is now entered to perform the algebraic calculation for each of
1 ; a line in the range 0 - 9999 has been entered.
1 ; a leading decimal point has been found in a number.
1 ; a known string array element.
1 ; a comma separator has been encountered in the DEF FN argument list.
1 ; a bulky operating system into an 8K ROM. It simply calculates
1 ; a branch of the editing loop to deal with control characters
1 ; a BASIC line or the input buffer. This includes listing to a printer
1 ; ^ ^ ^ ^ ^ ^
1 ; Zero suffices for a before but the after should logically be infinity.
1 ; Zero is a special case stored as 5 zeros.
1 ; ZX Spectrum BASIC Programming by Steven Vickers 1982.
1 ; You'll normally get error 4, ('Out of memory'), although sometimes the system
1 ; You can get round the missing chr$ 6 handler by sending multiple print
1 ; Y will hold -2 to -1 if this is quadrant III.
1 ; With the parameter zero, a random start point is used depending on
1 ; With positive numbers a carry denotes the result is out of integer range.
1 ; With negative numbers a carry denotes the result is within range.
1 ; With an integer expression, it sets the uppermost memory
1 ; When used as a calculator literal it duplicates the last value on the
1 ; When a small integer is converted to a floating point number the last two
1 ; When a calculator subroutine needs to put a value on the calculator
1 ; We know, from above, how to calculate the angle a using asn(x).
1 ; We arrived here from SCANNING with CH-ADD pointing to the initial '('
1 ; We are about to load data so change the border colours.
1 ; We also have to consider that this defined function may form part of the
1 ; WORKSP/STKBOT/STKEND though no use is made of this. The routines also
1 ; Variable in assignment
1 ; Using the syntax tables, the parser has already checked for a start and
1 ; User doesn't see report but the flashing error marker
1 ; Used to parse DEF FN
1 ; Used in 16 bit multiplication
1 ; Use zero routine
1 ; Use of symbol and graphics codes
1 ; Update NEXT LINE but consider
1 ; Unlike some BASICs the line number need not exist.
1 ; Unary so on entry HL points to last value, DE to stkend
1 ; Trigonometry is rocket science. It is also used by carpenters and pyramid
1 ; Tp = tone period = 236 + 2048*H + 32*(L>>2) + 8*(L&0x3)
1 ; Tokens and User defined graphics are now separated.
1 ; To be fair, this only applies if the last channel was other than 'K', 'S'
1 ; This versatile routine is used to find the address of the next line
1 ; This tight loop deals with combinations of positional controls and
1 ; This test routine is called when printing carriage return, when considering
1 ; This table is used to look up the calculator literals associated with
1 ; This table is used in the first instance for the first character of an
1 ; This table is used by the routine above to find one of the three
1 ; This table is used by INDEXER routine to find the offsets to
1 ; This table is indexed with the operation code obtained from the above
1 ; This subroutine, called from CL-ALL, CLS-LOWER and AUTO-LIST and above,
1 ; This subroutine searches a message or the token table for the
1 ; This subroutine returns zero if no further printing is required
1 ; This subroutine puts five registers on the calculator stack.
1 ; This subroutine is used to get two coordinate expressions for the three
1 ; This subroutine is used from ED-EDIT, str$ and read-in to reset the
1 ; This subroutine is used by the PRINT-FP routine and the decimal to FP
1 ; This subroutine is called whenever the line in the editing area or
1 ; This subroutine is called twice from the INPUT command when normal
1 ; This subroutine is called twice from above when printing floating-point
1 ; This subroutine is called from four places to calculate the address
1 ; This subroutine is called from OUT-LINE to print a flashing error
1 ; This subroutine is called from INT-TO-FP and DEC-TO-FP to stack a digit
1 ; This subroutine is called from CL-LINE or CL-SCROLL with the HL register
1 ; This subroutine is called 11 times to copy the permanent colour items
1 ; This subroutine called from CLS, AUTO-LIST and MAIN-3
1 ; This subroutine ...
1 ; This status remains in force until reset by the routine above.
1 ; This simple routine is a 5-byte LDIR instruction
1 ; This seems to be legacy code from the ZX80/ZX81 as it is
1 ; This routine which continues from above prints a carriage return
1 ; This routine uses HL only and returns with that register holding
1 ; This routine terminates the above routine and is also called from the
1 ; This routine sets the editing area, workspace and calculator stack
1 ; This routine sets a flag so that subsequent print related commands
1 ; This routine searches the program area for one of the above three keywords.
1 ; This routine reads a line number in the editing area returning the number
1 ; This routine puts the last value on the calculator stack into the accumulator
1 ; This routine prints printable characters and continues into
1 ; This routine prints a whole BASIC line and it is called
1 ; This routine prints a question mark which is commonly
1 ; This routine places one or more digits found in a BASIC line
1 ; This routine performs two functions on the angle, in radians, that forms
1 ; This routine moves the cursor left. The complication is that it must
1 ; This routine just loads the DE register with the contents of the two
1 ; This routine is used, in the first instance, by the multiply calculator
1 ; This routine is used when printing floating point numbers to calculate
1 ; This routine is used to search two-byte hash tables for a character
1 ; This routine is used to get the two coordinates of STRING$, ATTR and POINT.
1 ; This routine is used to copy 8 text lines from the printer buffer
1 ; This routine is used to backtrack to a command token and then
1 ; This routine is used on many occasions when extending a dynamic area
1 ; This routine is used often to get the address, in HL, of a BASIC line
1 ; This routine is used 10 times to advance along a DEF FN statement
1 ; This routine is remarkable for its brevity - 7 bytes.
1 ; This routine is not used by the ROM but allows users to evaluate
1 ; This routine is designed to deal with something that is known to be in the
1 ; This routine is called twice when printing floating point numbers and also
1 ; This routine is called twice by addition to prepare the two numbers. The
1 ; This routine is called once only to create a single space
1 ; This routine is called once from MAIN-2 when the BASIC line is to
1 ; This routine is called on a number of occasions to check if syntax is being
1 ; This routine is called from the FOR command to test for an initial
1 ; This routine is called from PRINT ITEMS above, and also LIST as in
1 ; This routine is called from COPY-LINE, when interrupts are disabled,
1 ; This routine is called from COPY and COPY-BUFF to output a line of
1 ; This routine is called from CLASS-03 when a command may be followed by
1 ; This routine is called from AUTO-LIST
1 ; This routine is called four times to place the value zero on the
1 ; This routine is called by the mathematical routines - FP-TO-BC, PRINT-FP,
1 ; This routine is called by MAKE-ROOM to adjust upwards and by RECLAIM to
1 ; This routine is called before any character is output while outputting
1 ; This routine is also used to print the exponent of E-format numbers.
1 ; This routine gets a floating point number e.g. 127.4 from the calculator
1 ; This routine finds the floating point number represented by an expression
1 ; This routine finds the data entry in the STRMS area for the specified
1 ; This routine fetches a byte and word from the calculator stack
1 ; This routine extracts a line number, at an address that has previously
1 ; This routine entered at OUT-SP-NO is used to compute then output the first
1 ; This routine deals with user-defined functions.
1 ; This routine deals with print items as in
1 ; This routine considers a single positional character ';', ',', '''
1 ; This routine compares a line number supplied in BC with an addressed
1 ; This routine clears an arbitrary 256 bytes of memory.
1 ; This routine checks that the character in A is alphanumeric
1 ; This routine checks that the character in A is alphabetic
1 ; This routine checks that the ASCII character in A is numeric
1 ; This routine calls the mathematical routine to multiply HL by DE in runtime.
1 ; This routine alters a single byte in the 64K address space.
1 ; This routine also recovers from an error situation where, for instance, an
1 ; This routine allows a one-byte instruction to stack up to 32 constants
1 ; This routine addresses a system variable ATTR_T, MASK_T or P-FLAG in HL.
1 ; This raises the first number X to the power of the second number Y.
1 ; This produces an automatic listing in the upper screen.
1 ; This point is used to print ASCII characters 32d - 127d.
1 ; This loop renders the similar loop at V-PASS redundant.
1 ; This is what causes 2 + 2 to give the answer 4.
1 ; This is therefore using the alternate set.
1 ; This is the service routine for the input stream of the keyboard channel 'K'.
1 ; This is the routine that evaluates that expression.
1 ; This is puzzling as very careful consideration must have been given to
1 ; This is now used to determine if the 'K' cursor is to be printed but this
1 ; This is known as Procrustean lengthening and shortening after a
1 ; This is chr$ 14.
1 ; This is called to evaluate a complex structure that has been found, in
1 ; This is called from ED-EDIT to clear workspace if edit key is
1 ; This is an exit branch from PO-1-OPER, PO-2-OPER
1 ; This is a unary operation, so on entry HL points to the last value and DE
1 ; This is a fundamental transcendental function from which others such as cos
1 ; This is a fundamental transcendental function from which others such as asn
1 ; This is a continuation of the restart BC-SPACES
1 ; This is a compact and highly versatile routine.
1 ; This important subroutine is used to calculate the character output
1 ; This important routine is called during runtime and from LINE-SCAN
1 ; This has no alternative use in input mode.
1 ; This function subroutine returns the attributes of a screen location -
1 ; This function returns the integer of x, which is just the same as truncate
1 ; This function returns the code of a bit-mapped character at screen
1 ; This entry point is used to move the stack back to its normal place
1 ; This entry point is used to create BC spaces in various areas such as
1 ; This entry point is used prior to input and prior to the execution,
1 ; This entry point is not used in this ROM but would
1 ; This entry point is from the ED-UP with HL addressing E_PPC_hi
1 ; This entry point is from ED-DOWN with HL addressing E_PPC
1 ; This entry point is also called from CL-ALL below to
1 ; This ensures that in a low memory situation, that valid line numbers can
1 ; This enables a$(2 TO) to return a null string if the passed string is
1 ; This common code is used to transfer the character bytes to memory.
1 ; This command sets the SEED for the RND function to a fixed value.
1 ; This command runs a program starting at an optional line.
1 ; This command routine sets the border to one of the eight colours.
1 ; This command reclaims the space used by the variables.
1 ; This command just jumps back to SAVE-ETC to handle the four tape commands.
1 ; This command is mysterious.
1 ; This command copies the top 176 lines to the ZX Printer
1 ; This combination of routines is called from 20 places when
1 ; This clever routine is used to check and evaluate an integer expression
1 ; This class routine is also called from INPUT and READ to find the
1 ; This call entry point is used to update the system variables e.g. by RETURN.
1 ; This bug does not apply to embedded PRINT items as it is quite permissible
1 ; This branch is taken from LOOK-VARS when a defined function is currently
1 ; This alters the position where subsequent READ commands look for data.
1 ; This acts on the lower screen and deletes the character to left of
1 ; This acts on the cursor in the lower section of the screen in both
1 ; This acts on the cursor in the lower screen in both editing and input
1 ; They are treated the same and the old value is overwritten.
1 ; These will not be encountered with the keyboard but would be handled
1 ; These two subroutines are called while editing.
1 ; These routines would have opened any buffers associated with the stream
1 ; These routines never get called while the editor is being used for input.
1 ; These routines have 3 entry points -
1 ; These just generate an error report as the ROM is 'incomplete'.
1 ; These are the 11 subroutines accessed by the above table.
1 ; There seems to have been an unsuccessful attempt to circumvent the use
1 ; There is some point in coming here as, as well as once creating buffers,
1 ; There is no need to open the printer buffer as it is there already
1 ; The zero has been fetched from the calculator stack but not deleted and
1 ; The variable name to be matched is in C.
1 ; The value is first rounded up and then converted to integer.
1 ; The user has pressed SHIFT 1 to bring edit line down to bottom of screen.
1 ; The ultimate power of channels and streams died at birth.
1 ; The tone period is measured in T states and consists of
1 ; The token is in E, and D holds a statement count, decremented from zero.
1 ; The test will always fail and the jump to ED-EDGE-2 will be taken.
1 ; The table requires a zero end-marker as the letter has been
1 ; The system variables are in no particular order except that STKEND, the first
1 ; The syntax of string slicing is very natural and it is as well to reflect
1 ; The subgroup 0-3 needs to be manipulated to form the next available four
1 ; The starting point was PROG - 1 or the end of a line.
1 ; The single entry point EACH-STMT is used to
1 ; The sign byte $00 +ve or $FF -ve is in C.
1 ; The second routine fetches 16-bit integers to the BC register pair
1 ; The routines alter the output address of the current channel so that
1 ; The routine would have to deal with that and exit to OPEN_END with BC
1 ; The routine should check a flag or HL address and simply return if COPY
1 ; The routine itself works out which command has called it by examining the
1 ; The routine is also called from the syntax path of DIM command to check the
1 ; The routine begins by checking for an optional STEP.
1 ; The routine CL-SC-ALL is called once from PO to scroll all the display
1 ; The return will be to here if no scrolling occurred
1 ; The return address STMT-RET is dropped and the rest of line ignored.
1 ; The resulting waveform has a duty ratio of exactly 50%.
1 ; The result lies in the range -1 to +1.
1 ; The result is zero if both values are zero else a non-zero value.
1 ; The restore command sets the system variable for the data address to
1 ; The report line must accommodate a 4-digit line number and a 3-digit
1 ; The reason one routine is made to handle two apparently unrelated tasks
1 ; The pointer will be the next line if continuing from above or to
1 ; The point subroutine is called from s-point via the scanning functions
1 ; The pause command takes as its parameter the number of interrupts
1 ; The parser has already checked the expression the result of which is on
1 ; The parameter tables have already evaluated the presence of a variable
1 ; The parameter or "Syntax" table
1 ; The open stream look-up table consists of matched pairs.
1 ; The offset table
1 ; The number of dimensions is still in A.
1 ; The method is to advance from the beginning of the line each time,
1 ; The message <b><font color=#333388>'scroll?'</font></b> appears here with last byte inverted.
1 ; The memory.
1 ; The main screen displays part of the BASIC program and the user wishes
1 ; The main scanning loop
1 ; The line number, or residual part, is held in HL and the BC register
1 ; The last few commands appear to have been added in a rush but their syntax
1 ; The instruction at <A href="#L257D">L257D</a> should just be a RET.
1 ; The initialization phase.
1 ; The highest location is a statement byte followed by a two-byte line number.
1 ; The fourteen pointers to dynamic memory, starting with VARS and ending
1 ; The four service subroutines for routines in the scanning function table
1 ; The fix therefore would be to ensure that CLASS-07 and CLASS-09 make
1 ; The first terminator is found in escaped input items only,
1 ; The first of these routines fetches a 8-bit integer (range 0-255) from the
1 ; The exception to the last rule is when the result is -65536
1 ; The evaluation process is quite complex as the Spectrum has to parse two
1 ; The entry points from control character table are PO-2-OPER and PO-1-OPER.
1 ; The entire free RAM is available to each BASIC statement.
1 ; The enter key has been pressed to have BASIC line or input accepted.
1 ; The editor is called to prepare or edit a BASIC line.
1 ; The editing area or workspace is cleared depending on context.
1 ; The definition can be anywhere in the program area but these are best
1 ; The default stream is stream 2 which is normally the upper screen
1 ; The cosine of angle x is the adjacent side (a) divided by the hypotenuse 1.
1 ; The comma control character. The 32 column screen has two 16 character
1 ; The colours used for the lower screen are based on this.
1 ; The close stream routines in fact have no ancillary actions to perform
1 ; The character that has been received can now be processed.
1 ; The channel letter is followed by an 8-bit displacement to the
1 ; The calculator stack increases by 5 bytes.
1 ; The branch was to here if a jump is to made to a new line number
1 ; The branch was here from LINE-NEW if BASIC is branching.
1 ; The bloke was hatstand and slain by Theseus.
1 ; The bit-mapped UDGs are ignored which is curious as it requires only a
1 ; The behaviour and options are quite different in the various modes
1 ; The above section deals with the flexible syntax allowed.
1 ; The Table INDEXING routine
1 ; The Stream Opening Routines.
1 ; The Spectrum's main stream output command.
1 ; The Spectrum screen arrangement leads to the L register already holding
1 ; The REM command routine.
1 ; The Plot subroutine
1 ; The LPRINT command joins here.
1 ; The GO TO command routine is also called by GO SUB and RUN routines
1 ; The GO SUB command diverts BASIC control to a new line number
1 ; The Error reports with the last byte inverted. The first entry
1 ; The Channel and Streams Routines
1 ; The Calculator
1 ; The CONTINUE command transfers the OLD (but incremented) values of
1 ; The Boolean OR operator. e.g. X OR Y
1 ; The BASIC interpreter has found a command code $CE - $FF
1 ; The B register holds the current line.
1 ; The B register holds on entry the number of lines to be cleared 1-24.
1 ; The <b><font color=#333388>'get-argt'</font></b> function is designed to modify the angle and its sign
1 ; The 16 2*2 mosaic characters 128-143 decimal are formed from
1 ; The 1-byte offset limits their location to within 255 bytes of their
1 ; That task, in fact, is performed here by the dual-area routine CLEAR-SP.
1 ; That is the previous statement was a GO TO, GO SUB, RUN, RETURN, NEXT etc..
1 ; That is quite easy to understand. However you don't have to make it much
1 ; Test for scroll
1 ; Temporary colour items
1 ; Table search
1 ; Table of priorities
1 ; Table of operators
1 ; THE <b><font color=#333388>'ZX81 NAME'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'ZX SPECTRUM CHARACTER SET'</font></b>
1 ; THE <b><font color=#333388>'ZERO OR ONE'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'VERIFY CONTROL'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'VAL and VAL$'</font></b> FUNCTIONS
1 ; THE <b><font color=#333388>'USR'</font></b> FUNCTION
1 ; THE <b><font color=#333388>'USR STRING'</font></b> FUNCTION
1 ; THE <b><font color=#333388>'UNARY MINUS'</font></b> OPERATION
1 ; THE <b><font color=#333388>'TRIGONOMETRIC'</font></b> FUNCTIONS
1 ; THE <b><font color=#333388>'TOKEN'</font></b> TABLES
1 ; THE <b><font color=#333388>'TEST FOR ZERO'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'TEST FOR CHANNEL K'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'TEST FIVE SPACES'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'TANGENT'</font></b> FUNCTION
1 ; THE <b><font color=#333388>'TABLE OF CONSTANTS'</font></b>
1 ; THE <b><font color=#333388>'TABLE OF ADDRESSES'</font></b>
1 ; THE <b><font color=#333388>'STRING CONCATENATION'</font></b> OPERATION
1 ; THE <b><font color=#333388>'STRING AND NUMBER'</font></b> OPERATION
1 ; THE <b><font color=#333388>'STR$'</font></b> FUNCTION
1 ; THE <b><font color=#333388>'START-NEW'</font></b> BRANCH
1 ; THE <b><font color=#333388>'START'</font></b>
1 ; THE <b><font color=#333388>'STACK NUMBER'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'SQUARE ROOT'</font></b> FUNCTION
1 ; THE <b><font color=#333388>'SPARE'</font></b> LOCATIONS
1 ; THE <b><font color=#333388>'SKIP OVER'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'SKIP CONSTANTS'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'SINE'</font></b> FUNCTION
1 ; THE <b><font color=#333388>'SIGNUM'</font></b> FUNCTION
1 ; THE <b><font color=#333388>'SET STACK POINTERS'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'SERIES GENERATOR'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'SEPARATOR'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'SEMI-TONE'</font></b> TABLE
1 ; THE <b><font color=#333388>'SAVE/LOAD RETURN'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'SAVE CONTROL'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'RETURN'</font></b> COMMAND
1 ; THE <b><font color=#333388>'REPEAT KEY'</font></b> BRANCH
1 ; THE <b><font color=#333388>'REMOVE FLOATING POINT'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'REM'</font></b> COMMAND
1 ; THE <b><font color=#333388>'REDUCE ARGUMENT'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'RECURSIVE PRINTING'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'READ-IN'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'RE-STACK TWO "SMALL" INTEGERS'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'RE-STACK ONE "SMALL" INTEGER'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'RAM CHECK'</font></b> SECTION
1 ; THE <b><font color=#333388>'PRINT OUTPUT'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'PRINT CHARACTER'</font></b> RESTART
1 ; THE <b><font color=#333388>'PRINT ANY CHARACTER'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'PRINT ALL CHARACTERS'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'PREPARE TO MULTIPLY OR DIVIDE'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'POSITION STORE'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'POSITION FETCH'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'PEEK'</font></b> FUNCTION
1 ; THE <b><font color=#333388>'OR'</font></b> OPERATOR
1 ; THE <b><font color=#333388>'OPEN CHANNEL'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'ONE SPACE'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'NUMBER AND NUMBER'</font></b> OPERATION
1 ; THE <b><font color=#333388>'NOT'</font></b> FUNCTION
1 ; THE <b><font color=#333388>'NON-MASKABLE INTERRUPT'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'NEW'</font></b> COMMAND
1 ; THE <b><font color=#333388>'NATURAL LOGARITHM'</font></b> FUNCTION
1 ; THE <b><font color=#333388>'MULTIPLY'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'MODULUS'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'MESSAGE PRINTING'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'MERGE CONTROL'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'MASKABLE INTERRUPT'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'MAIN OUTPUT'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'MAIN EXECUTION LOOP'</font></b>
1 ; THE <b><font color=#333388>'LOCATE MEMORY'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'LOAD CONTROL'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'LINE DRAWING'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'LET'</font></b> COMMAND
1 ; THE <b><font color=#333388>'LESS THAN ZERO'</font></b> OPERATION
1 ; THE <b><font color=#333388>'LEN'</font></b> FUNCTION
1 ; THE <b><font color=#333388>'KEYBOARD'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'KEYBOARD SCANNING'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'KEYBOARD INPUT'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'KEYBOARD DECODING'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'KEY-TEST'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'KEY'</font></b> TABLES
1 ; THE <b><font color=#333388>'JUMP-TRUE'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'JUMP'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'INT'</font></b> FUNCTION
1 ; THE <b><font color=#333388>'INPUT'</font></b> COMMAND
1 ; THE <b><font color=#333388>'INPUT CONTROL'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'INPUT ADDRESS'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'INITIAL STREAM'</font></b> DATA
1 ; THE <b><font color=#333388>'INITIAL CIRCLE/DRAW PARAMETERS'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'INITIAL CHANNEL'</font></b> INFORMATION
1 ; THE <b><font color=#333388>'IN'</font></b> FUNCTION
1 ; THE <b><font color=#333388>'GREATER THAN ZERO'</font></b> OPERATOR
1 ; THE <b><font color=#333388>'GET ATTRIBUTE ADDRESS'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'FREE MEMORY'</font></b> USER ROUTINE
1 ; THE <b><font color=#333388>'EXPONENTIATION'</font></b> OPERATION
1 ; THE <b><font color=#333388>'EXP'</font></b> FUNCTION
1 ; THE <b><font color=#333388>'EXCHANGE'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'ERROR-2'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'ERROR'</font></b> RESTART
1 ; THE <b><font color=#333388>'END-CALC'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'EDITOR-FULL'</font></b> ERROR ROUTINE
1 ; THE <b><font color=#333388>'DRAW'</font></b> COMMAND
1 ; THE <b><font color=#333388>'DOUBLE ANGLE FORMULA'</font></b>
1 ; THE <b><font color=#333388>'DIVISION'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'DECREASE THE COUNTER'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'CURSOR RIGHT'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'CURSOR LEFT'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'CREATE BC SPACES'</font></b> RESTART
1 ; THE <b><font color=#333388>'COSINE'</font></b> FUNCTION
1 ; THE <b><font color=#333388>'CONTROL CHARACTER'</font></b> TABLE
1 ; THE <b><font color=#333388>'COMPARISON'</font></b> OPERATIONS
1 ; THE <b><font color=#333388>'COLLECT NEXT CHARACTER'</font></b> RESTART
1 ; THE <b><font color=#333388>'COLLECT CHARACTER'</font></b> RESTART
1 ; THE <b><font color=#333388>'CODE'</font></b> FUNCTION
1 ; THE <b><font color=#333388>'CODE OUTPUT'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'CLS-LOWER'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'CLS'</font></b> COMMAND
1 ; THE <b><font color=#333388>'CLOSE-2'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'CLOSE STREAM'</font></b> SUBROUTINES
1 ; THE <b><font color=#333388>'CLOSE STREAM LOOK-UP'</font></b> TABLE
1 ; THE <b><font color=#333388>'CLOSE #'</font></b> COMMAND
1 ; THE <b><font color=#333388>'CLEAR TEXT LINES'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'CL-SET'</font></b> ROUTINE
1 ; THE <b><font color=#333388>'CIRCLE/DRAW CONVERGENCE POINT'</font></b>
1 ; THE <b><font color=#333388>'CIRCLE'</font></b> COMMAND
1 ; THE <b><font color=#333388>'CHR$'</font></b> FUNCTION
1 ; THE <b><font color=#333388>'CH ADD + 1'</font></b> SUBROUTINE
1 ; THE <b><font color=#333388>'CALCULATE'</font></b> RESTART
1 ; THE <b><font color=#333388>'BEEP'</font></b> COMMAND
1 ; THE <b><font color=#333388>'ARCTAN'</font></b> FUNCTION
1 ; THE <b><font color=#333388>'ARCSIN'</font></b> FUNCTION
1 ; THE <b><font color=#333388>'ARCCOS'</font></b> FUNCTION
1 ; THE <b><font color=#333388>'ARC LOOP'</font></b>
1 ; THE <b><font color=#333388>'ARC END'</font></b>
1 ; THE <b><font color=#333388>'ABSOLUTE MAGNITUDE'</font></b> FUNCTION
1 ; TASM cross-assembler directives.
1 ; System variable ERR_SP still points to editing error handler.
1 ; Syntax has been checked and the two comma-separated values are on the
1 ; Success!
1 ; Subtraction is done by switching the sign byte/bit of the second number
1 ; Stream data
1 ; Storing -ve integers in two's complement form, means that they are ready for
1 ; Store integer
1 ; Store in a memory area ($C0 etc.)
1 ; Store a positive integer
1 ; Storage of variables. For full details - see chapter 24.
1 ; Storage of numbers in 5 byte form.
1 ; Stop or Break was encountered so consider CONTINUE.
1 ; Steven Vickers, Pitman Pocket Guide to the Spectrum, 1984.
1 ; Steven Vickers writing in comp.sys.sinclair on 20-DEC-1993
1 ; Statement loop
1 ; Start End
1 ; Stack variable component
1 ; Stack literals ($34)
1 ; Stack function argument
1 ; Stack accumulator
1 ; Stack a constant (A0 etc.)
1 ; Stack Digit
1 ; Stack BC register pair
1 ; Something of significance is being passed to these ghost routines in the
1 ; Some uses can be quite abstract but the principles can be seen in simple
1 ; Some of these codes and bits may be altered later if the context suggests
1 ; Some e.g. 02 are only called once so a call to the command is made from
1 ; Some classes e.g. 07 and 0B have the same address in all invocations
1 ; Some class routines check syntax entirely and some leave this task for the
1 ; So nothing to do
1 ; So any variable name is higher that $3F and can be distinguished
1 ; So an assembly language programmer who has disabled interrupts to use
1 ; So +1 is 00000000 00000000 00000001 00000000 00000000
1 ; Single operation (3B)
1 ; Sinclair BASIC requires no poking of system variables.
1 ; Sinclair BASIC adheres to the ANSI-78 standard and a LET is required in
1 ; Since these can only be evaluated in context and were defaulted to
1 ; Since the three angles of any triangle add up to 180 degrees, or pi radians,
1 ; Since the maximum actual line limit is 9999 then the system limit, 16383
1 ; Since angle x plus angle y equals a right-angle, we can find angle y by
1 ; Since AT and TAB cannot be entered this point is never reached
1 ; Similarly by eliminating BIN and '.' now it is later able to assume that
1 ; Similarly PRINT TAN (3*PI/2), TAN (5*PI/2) etc.
1 ; Shift floating point number right
1 ; Set permanent colours
1 ; Set channel flags
1 ; Secondly it converts the angle in radians to a fraction of a right angle,
1 ; Sean Irvine for default list of section headings
1 ; Scanning variable routines
1 ; Scanning main loop
1 ; Scanning is evaluating the expression after the '=' and the variable
1 ; Scanning function table
1 ; Scanning function routines
1 ; Scanning function (FN)
1 ; Scanning SCREEN$
1 ; Scanning ATTR
1 ; Scan expression or sub-expression
1 ; Save header and program/data bytes
1 ; SET-MIN is called at the start of the MAIN-EXEC loop and prior to
1 ; S-BIN and S-DECIMAL are the same
1 ; Run a direct command
1 ; Routine to control loudspeaker
1 ; Returning early from subroutine
1 ; Return result of evaluating next expression
1 ; Result in range 0 to pi.
1 ; Report and line number outputting
1 ; Remember the edit line will contain characters and tokens
1 ; Recursive string functions are possible using VAL$ instead of VAL and the
1 ; Recursion is not allowed: i.e. the definition of a function should not use
1 ; Reclaim edit-line?
1 ; Read line number of line in editing area
1 ; REPORT-G
1 ; Put two numbers in BC register
1 ; Put stack in A register
1 ; Probably for compatibility with other BASICs particularly ZX81 BASIC.
1 ; Printable character(s)
1 ; Print the cursor
1 ; Print question mark
1 ; Print position
1 ; Print items
1 ; Print comma
1 ; Print carriage return
1 ; Print a whole BASIC line
1 ; Print a floating point number
1 ; Print a flashing character
1 ; Prepare to add
1 ; Point to first and last locations of work space
1 ; Point Subroutine
1 ; Perform carriage return
1 ; Perform NEXT loop
1 ; Perform AUTO-LIST
1 ; Pass printer buffer to printer
1 ; Pass five registers to calculator stack
1 ; P_FLAG | | | | | | | | | are the permanent flags.
1 ; PRINT AT and from the general PRINT ALL characters routine to test if
1 ; PRINT AT 10,0;"The value of A is ";a
1 ; PRINT +"3 is the greatest.".
1 ; PRINT """Hooray!"" he cried."
1 ; PREP routines which gives
1 ; PORT 254 ($FE)
1 ; PORT | | | | | | | | |
1 ; PORT PORT
1 ; PO-TV-2 or PO-CONT.
1 ; PAUSE 0 pauses indefinitely.
1 ; PAPER 6; CLS will not turn the screen yellow and
1 ; Outputting numbers at start of BASIC line
1 ; Outputting characters in a BASIC line
1 ; Outputs a square wave of given duration and frequency
1 ; Output to port $FB -
1 ; Others for example CIRCLE (x,y,z) check the first part (x,y) using the
1 ; Open Screen stream.
1 ; Open Printer stream.
1 ; Open Keyboard stream.
1 ; One of the shortest and least used commands. As with 'OK' not an error.
1 ; One of the revolutionary concepts of Sinclair BASIC was that it supported
1 ; On exit, HL=result, DE=stkend.
1 ; On entry, as always with binary operations,
1 ; On entry, HL points to start of search area.
1 ; On entry, HL must point to the end of the something to be deleted.
1 ; On entry, HL addresses where the first location is to be created.
1 ; On entry the channel code entry is on the calculator stack with the next
1 ; On entry HL points to first operand (X) and DE to second operand (Y).
1 ; Offsets $C0 to $DF
1 ; OPEN-S Subroutine
1 ; OPEN-P Subroutine
1 ; OPEN-K Subroutine
1 ; OPEN-2 Subroutine
1 ; OPEN stream look-up table
1 ; Now store 1 in mem-0.
1 ; Now separate capslock 06 from modes 7-15.
1 ; Now enter a loop to print it
1 ; Now deal with a runtime error as opposed to an editing error.
1 ; Now consider the following character fetched earlier.
1 ; Now consider paper 2; #2; a$
1 ; Note this is not a subroutine but a branch of the main execution loop.
1 ; Note that this causes floating point numbers to be stripped from
1 ; Note that classes 00, 03 and 05 will fetch the addresses from this table.
1 ; Note that BIN need not have any '0's or '1's after it.
1 ; Note that ADD-CHAR precedes the table so we can't offset to it directly.
1 ; Note if you move alter the syntax table next line may have to be altered.
1 ; Note ERR_SP points here during line entry which allows the
1 ; Not all the calling routines raise an error with overflow so no attempt
1 ; Not a trivial task.
1 ; No real harm can come from SCREEN$(255,255) although the BASIC manual
1 ; No actual check on ranges is performed - that's up to the BASIC programmer.
1 ; No Room for line
1 ; Next is chr$ 15
1 ; Move cursor left when editing
1 ; Move a floating point number (31)
1 ; Mike Dailly for comments.
1 ; Merge a Line or Variable
1 ; Make Room
1 ; Main parser (BASIC interpreter)
1 ; MASK_T | | | | | | | | | that is 1 shows that the
1 ; Luckily this provides a mechanism for extending these in a shadow ROM
1 ; Lower screen copying
1 ; Loops till all colour items output, finally addressing the coordinates.
1 ; Long names may contain spaces but not colour controls (when assigned).
1 ; Load header or block of information
1 ; Load a data block
1 ; Literals $E0 to $FF
1 ; List to any stream.
1 ; Last updated: 13-DEC-2004
1 ; LPRINT "A"; etc..
1 ; LOOK-VARS
1 ; LOOK-PROG
1 ; LOG(2^A)
1 ; LIST, RUN, GO TO, GO SUB and RESTORE have problems and the latter may
1 ; LIST #15
1 ; LD DE,(DE+1) Subroutine
1 ; L0EAF with B holding 192 (and interrupts disabled) for a full-screen
1 ; Just listing a line makes it the current edit line.
1 ; It's even easier to subtract 1 from the angle and rectify the sign.
1 ; It would save two duplicate bytes and if we also got rid of that sub 8
1 ; It wasn't written here but in the ZX81 where the programmers had to squeeze
1 ; It was not the end-marker so a single statement byte remains at the base of
1 ; It was a string expression - start in DE, length in BC
1 ; It updates the system variables used to fetch the next line/statement.
1 ; It returns once a single item has been dealt with as it is part
1 ; It probably had a zippier label though as the intention is to simplify the
1 ; It performs a 'RESTORE 0' then CLEAR
1 ; It isn't very efficient and it would have been better to hold the
1 ; It is used to step along the 16-bit dimension sizes in array definitions.
1 ; It is quite permissible to send these to any stream.
1 ; It is popular to call this from machine code at point
1 ; It is not possible to erase an array, but it can be re-dimensioned to
1 ; It is more than one character but re-test current character so that 6 reset
1 ; It is further complicated in that it deals with TAB and AT characters
1 ; It is called from mult, truncate, negate and sgn.
1 ; It is called from above and also from PR-ITEM-3 to handle a single embedded
1 ; It is called from STK-VAR and from DIM. In the latter case syntax is not
1 ; It is called from SCANNING to isolate the required part of the structure.
1 ; It is called from MAIN-3 to extract the line number in preparation for
1 ; It is called from LINE-SCAN to check the syntax of the digits.
1 ; It is called from CLASS-01 when assigning to a string or array including
1 ; It is by calling this routine after any change that the cursor, for
1 ; It is bits 7-5 of the first character of a variable that allow
1 ; It is best to work through using, say, +-3.4 as examples.
1 ; It is at STMT-RET that the actual change in control takes place.
1 ; It is also used by the error routine to clear the respective
1 ; It is also used by STK-VAR to calculate array subscripts and by DIM to
1 ; It is also called from PRINT-ITEM to get the two numeric expressions that
1 ; It is also called from INPUT to input a numeric or string expression.
1 ; It is also called at STMT-RET after every statement.
1 ; It is a this stage of the ROM that the Spectrum ceases altogether to be
1 ; It could have been derived directly from atn using acs(x) = atn(sqr(1-x*x)/x).
1 ; It also clears the screen and the GO SUB stack.
1 ; Ironically the tape streamer is not accessed through streams and
1 ; Invoked in BASIC with:
1 ; Interestingly, in the Pitman pocket guide, 1984, Vickers says that the
1 ; Interestingly the calculator stack is moved from its normal place at the
1 ; Integer truncation towards zero ($3A)
1 ; Integer to floating point
1 ; In this form 1 is stored as
1 ; In this case HL points to the initial letter, bits 7-5
1 ; In runtime this 'command' is passed by but the syntax is checked when such
1 ; In fact, provided there is enough free RAM, the Spectrum can evaluate
1 ; In fact, after reducing the argument, the absolute value of the argument
1 ; In fact the alternate set is used for the whole routine.
1 ; In either case this is dealt with by recursive calls to SCANNING.
1 ; Ignore next 2 codes from key-input routine
1 ; If, for simplicity, two Spectrums were both using #15 as a bi-directional
1 ; If they are both integers, then go for the easy route.
1 ; If the statement was part of a direct command then -2 is used as a
1 ; If the number is negative then a similar process to that used in INT-STORE
1 ; If the character is greater than a space it is a required separator.
1 ; If so go to next statement which in the first case will be on next line.
1 ; If rejoining from earlier there will be a value 'x' on stack.
1 ; If no match is found a null string is returned.
1 ; If negative, the number is stored in 2's complement form so that it is
1 ; If mode was zero then, while printing a BASIC line, bit 2 of flags has been
1 ; If less, then it is a command class in the range 00 - 0B.
1 ; If continuing from above the value zero.
1 ; If checking syntax,
1 ; If an error occurs while editing, or inputting, then ERR_SP
1 ; If a user written machine-code program disables interrupts then it
1 ; IY for other purposes can still use the calculator for mathematical
1 ; INPUT and INPUT LINE converge here.
1 ; INPUT ITEM subroutine
1 ; INPUT ASSIGNMENT Subroutine
1 ; I digress.
1 ; However, this only gets called from OUT-LINE when printing the edit line
1 ; However, there are so many exchanges going on at the places this is invoked
1 ; However, ironically, only the LOAD command gets it right. It will not
1 ; However, by the clever use of string expressions and VAL, such recursion is
1 ; However, as sine and cosine are horizontal translations of each other,
1 ; However that wasn't the plan.
1 ; However it's just as easy to reduce the argument first and subtract the
1 ; However it wouldn't be wise to have two streams attached to the ZX Printer
1 ; However if we examine angle y then a/h is the sine of that angle.
1 ; However if the error code is now zero then the OK message will be printed.
1 ; However all 64 pixels in the character cell take any embedded colour
1 ; Here, perhaps, another Spectrum has said print #15; AT 0,0; "This is yellow"
1 ; Has the user just pressed the ENTER key ?
1 ; Happily no check is made as to whether ROM or RAM is addressed.
1 ; Handle subtraction (03)
1 ; Handle slicing of strings
1 ; Handle scrolling
1 ; Handle reserve room
1 ; Handle reclaiming space
1 ; Handle printing floating point
1 ; Handle display with line number
1 ; Handle delete (02)
1 ; Handle change of colour
1 ; Handle addition of BASIC line
1 ; Handle addition (0F)
1 ; Handle STOP command
1 ; Handle RUN command
1 ; Handle RESTORE command
1 ; Handle READ command
1 ; Handle RANDOMIZE command
1 ; Handle PRINT commands
1 ; Handle POKE command
1 ; Handle PLOT command
1 ; Handle PAUSE command
1 ; Handle OUT command
1 ; Handle OPEN# command
1 ; Handle NEXT command
1 ; Handle LPRINT command
1 ; Handle LLIST
1 ; Handle LIST
1 ; Handle IF command
1 ; Handle GO TO command
1 ; Handle GO SUB command
1 ; Handle FOR command
1 ; Handle EDIT key
1 ; Handle DIM command
1 ; Handle DEF FN command
1 ; Handle DATA command
1 ; Handle COPY command
1 ; Handle CONTINUE command
1 ; Handle CLEAR command
1 ; Handle CAT, ERASE, FORMAT, MOVE commands
1 ; Handle BORDER command
1 ; HL=first number, DE=second number
1 ; HL=HL*DE Subroutine
1 ; HL points to top line of third and must be copied to bottom of previous 3rd.
1 ; HL points to the stack or a location in MEM and no deletion occurs.
1 ; HL points to start of variable name after 'LET' in BASIC line.
1 ; HL points to last value int x
1 ; HL points to first number, DE to second.
1 ; HL points to 4th byte.
1 ; HL addresses the first number, DE addresses the second number.
1 ; Go to next statement
1 ; Get starting address of line, or line after
1 ; Get pixel address
1 ; Get next one
1 ; Get line number of next line
1 ; Get last value from calculator stack
1 ; Get from memory area ($E0 etc.)
1 ; General line checking
1 ; For integers the form is
1 ; For each command there exists a variable list of parameters.
1 ; For each code in the range $07 to $0F this table contains a
1 ; For arithmetic only, A holds the sign of the result which is stored in
1 ; For 8-bit integers there will be at most 3 digits.
1 ; For 16-bit integers there will be at most 5 digits.
1 ; Footnote. calling any location that holds JP (HL) is the equivalent to
1 ; Floating point to BC register
1 ; Floating point to A
1 ; Floating point form is an alternative method of storing numbers which can
1 ; First make statement zero number one leaving others unaffected.
1 ; First it ensures that the angle 'wraps round'. That if a ship turns through
1 ; Find start address of new line
1 ; Find integers
1 ; Find each statement
1 ; Find DATA, DEF FN or NEXT.
1 ; Finally see if an exponent has been input.
1 ; Fetch two numbers
1 ; Fetch two parameters from calculator stack
1 ; Fetch integer
1 ; Fetch a value
1 ; Fetch a number
1 ; FEFE [SHI] [ Z ] [ X ] [ C ] [ V ] | [ B ] [ N ] [ M ] [sym] [ SPC ] 7FFE
1 ; FDFE [ A ] [ S ] [ D ] [ F ] [ G ] | [ H ] [ J ] [ K ] [ L ] [ ENT ] BFFE
1 ; FBFE [ Q ] [ W ] [ E ] [ R ] [ T ] | [ Y ] [ U ] [ I ] [ O ] [ P ] DFFE
1 ; F7FE [ 1 ] [ 2 ] [ 3 ] [ 4 ] [ 5 ] | [ 6 ] [ 7 ] [ 8 ] [ 9 ] [ 0 ] EFFE
1 ; Expect numeric/string expression
1 ; Examples of direct commands are RUN, CLS, LOAD "", PRINT USR 40000,
1 ; Evaluates tangent x as sin(x) / cos(x).
1 ; Error A unless the argument is between -1 and +1.
1 ; Error 6 if the argument, in radians, is too close to one like pi/2
1 ; Entry point for all tape commands
1 ; Entry point OUT-NUM-2 is used from OUT-LINE to output the line number
1 ; Entry point OUT-NUM-1 is used by the Error Reporting code to print
1 ; Entering an existing line number deletes that line.
1 ; Entering a non-existent line allows the subsequent line to be edited next.
1 ; Enter/newline
1 ; Enter with: pitch on top of calculator stack
1 ; End of statement?
1 ; End of printing
1 ; End of line?
1 ; Editor routine for BASIC and INPUT
1 ; Editor error routine
1 ; Editing keys table
1 ; Early demonstrations of the Spectrum showed a single microdrive being
1 ; Early adverts said that the network and RS232 were in this ROM.
1 ; E-format to floating point
1 ; Dr. Ian Logan for labels and functional disassembly.
1 ; Dr. Frank O'Hara for labels and functional disassembly.
1 ; Documented by Alvin Albrecht.
1 ; Difference routine
1 ; Development of this ROM continued for another three months until the cost
1 ; Derived from asn above which is in turn derived from the preceding atn.
1 ; Decimal to floating point
1 ; DIM a(2,2,2,2,2,2,2,2,2,2,2,2,2) is possible and creates a multi-
1 ; DIM a$(3,3,10) can be considered as two dimensional array of ten-character
1 ; DELETE editing
1 ; DE (STKEND) points to start of value.
1 ; D holds parameter 0-9 for ink/paper 0,1 or 8 for bright/flash,
1 ; Cursor up editing
1 ; Cursor right editing
1 ; Cursor left editing
1 ; Cursor down editing
1 ; Cosines are calculated as the sine of the opposite angle rectifying the
1 ; Copy line routine
1 ; Control characters with operands
1 ; Continue here when dealing with TAB.
1 ; Compare line numbers
1 ; Command syntax example: OPEN #5,"s"
1 ; Command syntax example: BORDER 7
1 ; Command classes---01, 02, and 04
1 ; Command classes---00, 03, and 05
1 ; Command class---0B
1 ; Command class---09
1 ; Command class---04
1 ; Command class table
1 ; Command Syntax: STOP
1 ; Command Syntax example: PLOT 128,88
1 ; Come here after interpretation
1 ; Colour Item Routines
1 ; Collect line number
1 ; Clearing whole display area
1 ; Clear various editing areas
1 ; Clear edit/work space
1 ; Clear Printer Buffer
1 ; Check whether digit or letter
1 ; Check syntax
1 ; Check statement for DATA or DEF FN
1 ; Check signal being loaded
1 ; Check for valid digit
1 ; Check for a number marker
1 ; Check for BREAK key
1 ; Check available memory
1 ; Channels 'N' and 'B' are user channels and have been removed successfully
1 ; Channels 'K' and 'S' are system channels and it would be inappropriate
1 ; Channel code look-up table
1 ; Channel S flag
1 ; Channel P flag
1 ; Channel K flag
1 ; Certain control characters are followed by 1 or 2 operands.
1 ; Canned report messages
1 ; Canned cassette messages
1 ; CO-TEMP-3
1 ; CLASS-04 has also checked the variable and the name is in STRLEN_lo.
1 ; CIRCLE INK 2; 128,88,50 will not draw a red circle.
1 ; Byte 5 - unused but always zero.
1 ; Byte 4 - High byte
1 ; Byte 3 - Low byte of integer.
1 ; Byte 2 - sign byte, $00 +ve, $FF -ve.
1 ; Byte 1 - zero,
1 ; By default all expressions are positive and the spurious '+' is eliminated
1 ; Both integers and floating-point numbers can be stored in five bytes.
1 ; Both forms can be finished by pressing a key.
1 ; Begin by considering whether to print a leading sign for negative numbers.
1 ; BIN is really just a notational symbol and not a function.
1 ; BASIC line.
1 ; BASIC interface to BEEPER subroutine.
1 ; Attribute handling
1 ; At this point there is a looping return address on the stack, an error
1 ; At this point the start of the DEF FN argument list is on the machine stack.
1 ; As with the ZX80,
1 ; As with any command, there are two values on the machine stack at the time
1 ; As this defined function may be part of a hierarchy of defined functions
1 ; As the definition is just an expression, there would seem to be no means
1 ; As noted earlier, Vickers says there should have been an entry in
1 ; As it moves along the first list, the character address CH_ADD is stored
1 ; As an example, to output five seconds of middle C (261.624 Hz):
1 ; As a general rule the calculator avoids using the IY register.
1 ; As a consequence of this omission the buffer will needlessly
1 ; Apart from a couple of minor glitches, which you can now correct, the
1 ; Anyway doesn't matter, these routines are long gone.
1 ; Andy Styles for full relocatability implementation and testing. testing.
1 ; Andrew Owen for ZASM compatibility and format improvements.
1 ; An instruction fetch on $0008 may page in a peripheral ROM,
1 ; An important part of the runtime process is to check that the number of
1 ; An extra UDG might have been better.
1 ; An expression that begins with a quote requires special treatment.
1 ; An existing line with same number is deleted first.
1 ; An enigma.
1 ; An earlier mathematician Lewis Carroll may have been pleased that
1 ; An acquired programming skill is the ability to include brackets where
1 ; Alvin Albrecht for comments.
1 ; Although 32 memory storage locations can be addressed, only six
1 ; Alternatively the user wishes to clear the input buffer and start again.
1 ; Alternatively a direct statement has finished correctly.
1 ; Alternatively ...
1 ; Alter stream
1 ; Also from AUTO-LIST with HL addressing S_TOP just to update S_TOP
1 ; Also called from LIST-4.
1 ; Also a$(9 TO 5) returns a null string not an error.
1 ; All the remaining functions will be evaluated by a single call to the
1 ; All the other commands deal with the limit unsatisfactorily.
1 ; All that is being checked is that there are a valid set of comma-separated
1 ; All routines are capable of being run in two modes - syntax checking mode
1 ; Alex Pallero Gonzales for corrections.
1 ; Again it's up to the BASIC programmer to supply valid values of line/column.
1 ; Again a single class for four commands.
1 ; Afterwards, HL will point to the location before this.
1 ; Adjust pointers before making or reclaiming room
1 ; Add code to current line
1 ; Add back any carry
1 ; Acknowledgements
1 ; Acceptable characters at this point are carriage return and ':'.
1 ; ATTR_T | | | | | | | | |
1 ; A zero end-marker is required as channel 'R' is not present.
1 ; A string expression in brackets can be sliced. e.g. (STR$ PI) (3 TO )
1 ; A slice can itself be sliced ad infinitum
1 ; A simple return but when used as a calculator literal this
1 ; A simple form of 'PRINT #3' although it can output to 16 streams.
1 ; A short form of LIST #3. The listing goes to stream 3 - default printer.
1 ; A screen byte holds 8 pixels so it is necessary to rotate a mask
1 ; A pixel can be reset (inverse 1), toggled (over 1), or set ( with inverse
1 ; A numeric variable could be simple or an array element.
1 ; A new line is added to the BASIC program at the appropriate place.
1 ; A loop is now entered to insert the size of each dimension that was pushed
1 ; A loop is now entered to compare, by subtraction, each corresponding character
1 ; A list of comma-separated variables is assigned from a list of
1 ; A holds the derived offset $00-$1F.
1 ; A holds control $10 (INK) to $15 (OVER)
1 ; A holds $00-$1F offset.
1 ; A direct command is to be run or, if continuing from above,
1 ; A channel is an input/output route to a hardware device
1 ; A carriage return is 'printed' to screen or printer buffer.
1 ; A bracket at the start of a sub-expression may be spurious or necessary
1 ; A binary operation.
1 ; A General Note on Invalid Line Numbers.
1 ; A DEFB 02 delete is required immediately on using the calculator.
1 ; =========================================
1 ; =======================================
1 ; ==================================
1 ; ========= ==== == ======== === ======== ======== ==== === = === === ===
1 ; ===> there were many branches forward to here
1 ; ==> branch here from L-NUMERIC
1 ; ==> The branch was here if not in table.
1 ; <font color=#CC00FF>(n1,n2 -- r,q)</font>
1 ; <font color=#9900FF>Note.</font> while it would be pedantic to comment on every occasion a JP
1 ; <font color=#9900FF>Note.</font> this exit seems correct but the general-purpose routine S-STRING
1 ; <font color=#9900FF>Note.</font> this does allow a degree of nonsense to be accepted as in
1 ; <font color=#9900FF>Note.</font> this command should ensure that current channel is actually 'S'.
1 ; <font color=#9900FF>Note.</font> these invisible storage locations hold nothing meaningful for the
1 ; <font color=#9900FF>Note.</font> these commands should ensure that current channel is 'S'
1 ; <font color=#9900FF>Note.</font> the two-byte sequence 'rst 08; defb $0b' could replace the above jp.
1 ; <font color=#9900FF>Note.</font> the high byte of the line number is incorrectly compared with $F0
1 ; <font color=#9900FF>Note.</font> the COPY command rejoins here, essentially to execute the next
1 ; <font color=#9900FF>Note.</font> one of the class routines will eventually drop the return address
1 ; <font color=#9900FF>Note.</font> it would be better if the 2nd RRCA preceded the string test.
1 ; <font color=#9900FF>Note.</font> incidentally this is the only occasion in Spectrum BASIC when an
1 ; <font color=#9900FF>Note.</font> in a BASIC line we can safely backtrack to a colour parameter.
1 ; <font color=#9900FF>Note.</font> if either of the numeric expressions contain STR$ then the flag setting
1 ; <font color=#9900FF>Note.</font> for what was intended there should also have been an
1 ; <font color=#9900FF>Note.</font> for example line number 200 -
1 ; <font color=#9900FF>Note.</font> at this point we have a validated line number, not just an
1 ; <font color=#9900FF>Note.</font> as a general rule the calculator avoids using the IY register
1 ; <font color=#9900FF>Note.</font> any of the above seven will serve as a program end-marker.
1 ; <font color=#9900FF>Note.</font> although the calculator is performing a single operation most
1 ; <font color=#9900FF>Note.</font> While in editing/input mode should an error occur then RST 08 will
1 ; <font color=#9900FF>Note.</font> While a starting line can be specified it is
1 ; <font color=#9900FF>Note.</font> Though not used by the ROM as such, it has also been set up as
1 ; <font color=#9900FF>Note.</font> The routine seems designed to clear a buffer that follows the
1 ; <font color=#9900FF>Note.</font> Such code is made into subroutines to make programs easier to
1 ; <font color=#9900FF>Note.</font> LET a$(3 TO 6) = h$ will assign "hat " if h$ = "hat"
1 ; <font color=#9900FF>Note.</font> In BASIC, TAB is followed by a 16-bit number and was initially
1 ; <font color=#9900FF>Note.</font> If supplied with inappropriate high numbers the system may crash
1 ; <font color=#9900FF>Note.</font> For ZASM assembler replace following expression with SUB $13.
1 ; <font color=#9900FF>Note.</font> At each pass of the digit loop this will be divided by ten.
1 ; <font color=#9900FF>Note.</font>
1 ; <font color=#339933>(offset: $8C 'series-0C')</font>
1 ; <font color=#339933>(offset: $88 'series-08')</font>
1 ; <font color=#339933>(offset: $86 'series-06')</font>
1 ; <font color=#339933>(offset: $3D 're-stack')</font>
1 ; <font color=#339933>(offset: $38 'end-calc')</font>
1 ; <font color=#339933>(offset: $37 'greater-0' )</font>
1 ; <font color=#339933>(offset: $36 'less-0' )</font>
1 ; <font color=#339933>(offset: $35 'dec-jr-nz')</font>
1 ; <font color=#339933>(offset: $33 'jump')</font>
1 ; <font color=#339933>(offset: $32 'n-mod-m')</font>
1 ; <font color=#339933>(offset: $30 'not')</font>
1 ; <font color=#339933>(offset: $2f 'chr$')</font>
1 ; <font color=#339933>(offset: $2e 'str$')</font>
1 ; <font color=#339933>(offset: $2d 'usr-no')</font>
1 ; <font color=#339933>(offset: $2C 'in')</font>
1 ; <font color=#339933>(offset: $2B 'peek')</font>
1 ; <font color=#339933>(offset: $2A 'abs')</font>
1 ; <font color=#339933>(offset: $29 'sgn')</font>
1 ; <font color=#339933>(offset: $1e 'len')</font>
1 ; <font color=#339933>(offset: $1d 'val')</font>
1 ; <font color=#339933>(offset: $1c 'code')</font>
1 ; <font color=#339933>(offset: $1a 'read-in')</font>
1 ; <font color=#339933>(offset: $1B 'negate')</font>
1 ; <font color=#339933>(offset: $19 'usr-$')</font>
1 ; <font color=#339933>(offset: $18 'val$')</font>
1 ; <font color=#339933>(offset: $17 'strs-add')</font>
1 ; <font color=#339933>(offset: $16 'strs-eql')</font>
1 ; <font color=#339933>(offset: $15 'str-less')</font>
1 ; <font color=#339933>(offset: $14 'str-grtr')</font>
1 ; <font color=#339933>(offset: $13 'strs-neql')</font>
1 ; <font color=#339933>(offset: $12 'str-gr-eql')</font>
1 ; <font color=#339933>(offset: $11 'str-l-eql')</font>
1 ; <font color=#339933>(offset: $10 'str-&-no')</font>
1 ; <font color=#339933>(offset: $0E 'nos-eql')</font>
1 ; <font color=#339933>(offset: $0D 'no-less')</font>
1 ; <font color=#339933>(offset: $0C 'no-grtr')</font>
1 ; <font color=#339933>(offset: $0B 'nos-neql')</font>
1 ; <font color=#339933>(offset: $0A 'no-gr-eql')</font>
1 ; <font color=#339933>(offset: $08 'no-&-no')</font>
1 ; <font color=#339933>(offset: $07 'or' )</font>
1 ; <font color=#339933>(offset: $05 'division')</font>
1 ; <font color=#339933>(offset: $04 'multiply')</font>
1 ; <font color=#339933>(offset: $01 'exchange')</font>
1 ; <font color=#339933>(offset: $00 'jump-true')</font>
1 ; <font color=#339933>(offset $39: 'get-argt')</font>
1 ; <font color=#339933>(offset $27: 'int' )</font>
1 ; <font color=#339933>(offset $26: 'exp')</font>
1 ; <font color=#339933>(offset $25: 'ln')</font>
1 ; <font color=#339933>(offset $21: 'tan')</font>
1 ; <font color=#339933>(offset $20: 'cos')</font>
1 ; <font color=#339933>(offset $1F: 'sin')</font>
1 ; <font color=#339933>(Offset $28: 'sqr')</font>
1 ; <font color=#339933>(Offset $24: 'atn')</font>
1 ; <font color=#339933>(Offset $23: 'acs')</font>
1 ; <font color=#339933>(Offset $22: 'asn')</font>
1 ; <font color=#339933>(Offset $06: 'to-power')</font>
1 ; 76543210 meaning brief outline of format.
1 ; 4) Functions arcsin, arccosine and arctan enable one to calculate an unknown
1 ; 32-bit numbers as well from above
1 ; 32-bit multiplication to which it will resort if this overflows.
1 ; 32 bytes to the ZX Printer.
1 ; 3) Functions sine, cosine and tangent enable one to calculate the length
1 ; 3) CO TEMP-4 to handle a colour command such as FLASH 1
1 ; 254 | | | | | | | | |
1 ; 23697 |___|___|___|___|___|___|___|___|
1 ; 23696 |___|___|___|___|___|___|___|___| taken not from ATTR-T but from
1 ; 23695 |___|___|___|___|___|___|___|___|
1 ; 2) To find a token in held E.
1 ; 2) In any right-angled triangle the sum of the squares of the two shorter
1 ; 2) CO-TEMP-3 to handle a single embedded print colour item.
1 ; 111 for-next loop variable. 18 bytes.
1 ; 110 string array. 2 byte length + contents.
1 ; 101 variable length named numeric. 5 bytes.
1 ; 10010001 00000000 00000001
1 ; 10010000 00000000 00000010 <- now shift left and decrement exponent
1 ; 10000010 01000000 00000000 <- until a 1 abuts the imaginary point
1 ; 10000001 10000000 00000000 to the left of the mantissa.
1 ; 10000001 00000000 00000000
1 ; 10000000 the variables area end-marker.
1 ; 100 array of numbers. 2 byte length + contents.
1 ; 10 LET Babies cannot manage crocodiles = Babies are illogical AND
1 ; 10 BORDER 3 : PLOT VAL STR$ 128, VAL STR$ 100
1 ; 1) with 9 digits but 8 in mem-5-1 and A holding 4, carry set if rounding up.
1 ; 1) To find the D'th statement in a line.
1 ; 1) The sum of the three angles is always PI radians (180 degrees).
1 ; 1) CO-TEMP-2 to handle a series of embedded Graphic colour items.
1 ; 011 simple numeric variable. 5 bytes.
1 ; 010 - simple string, 110 - string array, 100 - array of numbers.
1 ; 010 string variable. 2 byte length + contents.
1 ; 0 or 1 for over/inverse.
1 ; 0 ^ 0 = 1.
1 ; 0 ^ -n = arithmetic overflow.
1 ; 0 ^ +n = 0.
1 ; ... so that INPUT_AD directs control to here at next call to WAIT-KEY
1 ; ... and again later at this point
1 ; -8->
1 ; -----------------------------------------------------------------
1 ; ----------------------------------------------------------
1 ; --------------------------------------------------------
1 ; -------------------------------------------------
1 ; -------- ------------------------ -----------------------
1 ; --------
1 ; -*-> the branch was here if a string existed.
1 ; -> this routine evaluates and outputs a colour control and parameter.
1 ; -> this entry point used by CLASS-07. e.g. the command PAPER 6.
1 ; -> the single entry point.
1 ; -> the scanning branch was here if not alphanumeric.
1 ; -> the mid-point entry point of the loop
1 ; -> the mid entry point of loop.
1 ; -> the initial entry point with HL addressing start of syntax table entry.
1 ; -> the entry point from above or LINE-RUN
1 ; -> entry point.
1 ; -> This initial entry point deals with two operands - AT or TAB.
1 ; -> This initial entry point deals with one operand INK to OVER.
1 ; -> The entry point is here if A is used as a running flag.
1 ; -> Entry point.
1 ; -> Entry point from CLASS-09. Embedded Graphic colour items.
1 ; - observation, Steven Vickers, 1984, Pitman.
1 ; - from a turn of the century newsgroup discussion initiated by Mike Wynne.
1 ; - Steven Vickers, 1984.
1 ; - - >
1 ; ** Part 6. EXECUTIVE ROUTINES **
1 ; * Note that a comma is required as a separator with the OPEN command
1 ; (multiplication is done by a sequence of additions).
1 ; (bits 7..2 of L) and a fine part (bits 1..0 of L) which
1 ; (PR-ALL-6 would require an extra 3 bytes of code).
1 ; ( so HL = $4800 or $5000 ) ( but also sometimes $4000 )
1 ; ( or in the case of mem-5 will become zero as a result of RLD instruction )
1 ; ( comment out, perhaps, for other assemblers - see Notes at end.)
1 ; >> This is where they were all headed for.
1 ; $FE |___|___|___|___|___|___|___|___|
1 ; $C0 to $C5 are required by the ROM and only the thirty bytes (6*5)
1 ; $C0 = numeric result, numeric operand. e.g. 'sin'
1 ; $80 = numeric result, string operand. e.g. 'code'
1 ; $7F - <b>Character: ' © ' </b>CHR$(127)
1 ; $7E - <b>Character: '~' </b>CHR$(126)
1 ; $7D - <b>Character: '}' </b>CHR$(125)
1 ; $7C - <b>Character: '|' </b>CHR$(124)
1 ; $7B - <b>Character: '{' </b>CHR$(123)
1 ; $7A - <b>Character: 'z' </b>CHR$(122)
1 ; $79 - <b>Character: 'y' </b>CHR$(121)
1 ; $78 - <b>Character: 'x' </b>CHR$(120)
1 ; $77 - <b>Character: 'w' </b>CHR$(119)
1 ; $76 - <b>Character: 'v' </b>CHR$(118)
1 ; $75 - <b>Character: 'u' </b>CHR$(117)
1 ; $74 - <b>Character: 't' </b>CHR$(116)
1 ; $73 - <b>Character: 's' </b>CHR$(115)
1 ; $72 - <b>Character: 'r' </b>CHR$(114)
1 ; $71 - <b>Character: 'q' </b>CHR$(113)
1 ; $70 - <b>Character: 'p' </b>CHR$(112)
1 ; $6F - <b>Character: 'o' </b>CHR$(111)
1 ; $6E - <b>Character: 'n' </b>CHR$(110)
1 ; $6D - <b>Character: 'm' </b>CHR$(109)
1 ; $6C - <b>Character: 'l' </b>CHR$(108)
1 ; $6B - <b>Character: 'k' </b>CHR$(107)
1 ; $6A - <b>Character: 'j' </b>CHR$(106)
1 ; $69 - <b>Character: 'i' </b>CHR$(105)
1 ; $68 - <b>Character: 'h' </b>CHR$(104)
1 ; $67 - <b>Character: 'g' </b>CHR$(103)
1 ; $66 - <b>Character: 'f' </b>CHR$(102)
1 ; $65 - <b>Character: 'e' </b>CHR$(101)
1 ; $64 - <b>Character: 'd' </b>CHR$(100)
1 ; $63 - <b>Character: 'c' </b>CHR$(99)
1 ; $62 - <b>Character: 'b' </b>CHR$(98)
1 ; $61 - <b>Character: 'a' </b>CHR$(97)
1 ; $60 - <b>Character: ' £ ' </b>CHR$(96)
1 ; $5F - <b>Character: '_' </b>CHR$(95)
1 ; $5E - <b>Character: '^' </b>CHR$(94)
1 ; $5D - <b>Character: ']' </b>CHR$(93)
1 ; $5C - <b>Character: '\' </b>CHR$(92)
1 ; $5B - <b>Character: '[' </b>CHR$(91)
1 ; $5A - <b>Character: 'Z' </b>CHR$(90)
1 ; $59 - <b>Character: 'Y' </b>CHR$(89)
1 ; $58 - <b>Character: 'X' </b>CHR$(88)
1 ; $57 - <b>Character: 'W' </b>CHR$(87)
1 ; $56 - <b>Character: 'V' </b>CHR$(86)
1 ; $55 - <b>Character: 'U' </b>CHR$(85)
1 ; $54 - <b>Character: 'T' </b>CHR$(84)
1 ; $53 - <b>Character: 'S' </b>CHR$(83)
1 ; $52 - <b>Character: 'R' </b>CHR$(82)
1 ; $51 - <b>Character: 'Q' </b>CHR$(81)
1 ; $50 - <b>Character: 'P' </b>CHR$(80)
1 ; $4F - <b>Character: 'O' </b>CHR$(79)
1 ; $4E - <b>Character: 'N' </b>CHR$(78)
1 ; $4D - <b>Character: 'M' </b>CHR$(77)
1 ; $4C - <b>Character: 'L' </b>CHR$(76)
1 ; $4B - <b>Character: 'K' </b>CHR$(75)
1 ; $4A - <b>Character: 'J' </b>CHR$(74)
1 ; $49 - <b>Character: 'I' </b>CHR$(73)
1 ; $48 - <b>Character: 'H' </b>CHR$(72)
1 ; $47 - <b>Character: 'G' </b>CHR$(71)
1 ; $46 - <b>Character: 'F' </b>CHR$(70)
1 ; $45 - <b>Character: 'E' </b>CHR$(69)
1 ; $44 - <b>Character: 'D' </b>CHR$(68)
1 ; $43 - <b>Character: 'C' </b>CHR$(67)
1 ; $42 - <b>Character: 'B' </b>CHR$(66)
1 ; $41 - <b>Character: 'A' </b>CHR$(65)
1 ; $40 = string result, numeric operand. e.g. 'str$'
1 ; $40 - <b>Character: '@' </b>CHR$(64)
1 ; $3F - <b>Character: '?' </b>CHR$(63)
1 ; $3E - <b>Character: '>' </b>CHR$(62)
1 ; $3D - <b>Character: '=' </b>CHR$(61)
1 ; $3C - <b>Character: '<' </b>CHR$(60)
1 ; $3B - <b>Character: ';' </b>CHR$(59)
1 ; $3A - <b>Character: ':' </b>CHR$(58)
1 ; $39 - <b>Character: '9' </b>CHR$(57)
1 ; $38 - <b>Character: '8' </b>CHR$(56)
1 ; $37 - <b>Character: '7' </b>CHR$(55)
1 ; $36 - <b>Character: '6' </b>CHR$(54)
1 ; $35 - <b>Character: '5' </b>CHR$(53)
1 ; $34 - <b>Character: '4' </b>CHR$(52)
1 ; $33 - <b>Character: '3' </b>CHR$(51)
1 ; $32 - <b>Character: '2' </b>CHR$(50)
1 ; $31 - <b>Character: '1' </b>CHR$(49)
1 ; $30 - <b>Character: '0' </b>CHR$(48)
1 ; $2F - <b>Character: '/' </b>CHR$(47)
1 ; $2E - <b>Character: '.' </b>CHR$(46)
1 ; $2D - <b>Character: '-' </b>CHR$(45)
1 ; $2C - <b>Character: ',' </b>CHR$(44)
1 ; $2B - <b>Character: '+' </b>CHR$(43)
1 ; $2A - <b>Character: '*' </b>CHR$(42)
1 ; $29 - <b>Character: ')' </b>CHR$(41)
1 ; $28 - <b>Character: '(' </b>CHR$(40)
1 ; $27 - <b>Character: ''' </b>CHR$(39)
1 ; $26 - <b>Character: '&' </b>CHR$(38)
1 ; $25 - <b>Character: '%' </b>CHR$(37)
1 ; $24 - <b>Character: '$' </b>CHR$(36)
1 ; $23 - <b>Character: '#' </b>CHR$(35)
1 ; $22 - <b>Character: '"' </b>CHR$(34)
1 ; $21 - <b>Character: '!' </b>CHR$(33)
1 ; $20 - <b>Character: ' ' </b>CHR$(32)
1 ; $0000 $4000 $5800 $5B00 $5C00 $5CB6 = CHANS
1 ; $00 = string result, string operand. e.g. 'val$'
1 ; "Due to a bug, if you bring in a peripheral channel and later use a colour
1 ; "Contrary to the manual, CLEAR doesn't execute a RESTORE" -
1 ; | F8 SAV| F9 RAN| FA IF | FB CLS| FC DRW| FD CLR| FE RET| FF CPY|
1 ; | F0 LIS| F1 LET| F2 PAU| F3 NXT| F4 POK| F5 PRI| F6 PLO| F7 RUN|
1 ; | E8 CON| E9 DIM| EA REM| EB FOR| EC GTO| ED GSB| EE INP| EF LOA|
1 ; | E0 LPR| E1 LLI| E2 STP| E3 REA| E4 DAT| E5 RES| E6 NEW| E7 BDR|
1 ; | D8 CIR| D9 INK| DA PAP| DB FLA| DC BRI| DD INV| DE OVR| DF OUT|
1 ; | D0 FMT| D1 MOV| D2 ERS| D3 OPN| D4 CLO| D5 MRG| D6 VFY| D7 BEP|
1 ; | C8 >= | C9 <> | CA LIN| CB THN| CC TO | CD STP| CE DEF| CF CAT|
1 ; | C0 USR| C1 ST$| C2 CH$| C3 NOT| C4 BIN| C5 OR | C6 AND| C7 <= |
1 ; | B8 LN | B9 EXP| BA INT| BB SQR| BC SGN| BD ABS| BE PEK| BF IN |
1 ; | B0 VAL| B1 LEN| B2 SIN| B3 COS| B4 TAN| B5 ASN| B6 ACS| B7 ATN|
1 ; | A8 FN | A9 PNT| AA SC$| AB ATT| AC AT | AD TAB| AE VL$| AF COD|
1 ; | A0 [Q]| A1 [R]| A2 [S]| A3 [T]| A4 [U]| A5 RND| A6 IK$| A7 PI |
1 ; | 98 [I]| 99 [J]| 9A [K]| 9B [L]| 9C [M]| 9D [N]| 9E [O]| 9F [P]|
1 ; | 90 [A]| 91 [B]| 92 [C]| 93 [D]| 94 [E]| 95 [F]| 96 [G]| 97 [H]|
1 ; | 88 136| 89 137| 8A 138| 8B 139| 8C 140| 8D 141| 8E 142| 8F 143|
1 ; | 80 128| 81 129| 82 130| 83 131| 84 132| 85 133| 86 134| 87 135|
1 ; | 78 x | 79 y | 7A z | 7B { | 7C | | 7D } | 7E ~ | 7F © |
1 ; | 70 p | 71 q | 72 r | 73 s | 74 t | 75 u | 76 v | 77 w |
1 ; | 68 h | 69 i | 6A j | 6B k | 6C l | 6D m | 6E n | 6F o |
1 ; | 60 £ | 61 a | 62 b | 63 c | 64 d | 65 e | 66 f | 67 g |
1 ; | 58 X | 59 Y | 5A Z | 5B [ | 5C \ | 5D ] | 5E ^ | 5F _ |
1 ; | 50 P | 51 Q | 52 R | 53 S | 54 T | 55 U | 56 V | 57 W |
1 ; | 48 H | 49 I | 4A J | 4B K | 4C L | 4D M | 4E N | 4F O |
1 ; | 40 @ | 41 A | 42 B | 43 C | 44 D | 45 E | 46 F | 47 G |
1 ; | 38 8 | 39 9 | 3A : | 3B ; | 3C < | 3D = | 3E > | 3F ? |
1 ; | 30 0 | 31 1 | 32 2 | 33 3 | 34 4 | 35 5 | 36 6 | 37 7 |
1 ; | 28 ( | 29 ) | 2A * | 2B + | 2C , | 2D - | 2E . | 2F / |
1 ; | 20 SP | 21 ! | 22 " | 23 # | 24 $ | 25 % | 26 & | 27 ' |
1 ; | 18 Pa0| 19 Pa1| 1A Pa2| 1B Pa3| 1C Pa4| 1D Pa5| 1E Pa6| 1F Pa7|
1 ; | 10 Ik0| 11 Ik1| 12 Ik2| 13 Ik3| 14 Ik4| 15 Ik5| 16 Ik6| 17 Ik7|
1 ; | 08 LFT| 09 RIG| 0A DWN| 0B UP | 0C DEL| 0D ENT| 0E SYM| 0F GRA|
1 ; | 00 Fl0| 01 Fl1| 02 Br0| 03 Br1| 04 In0| 05 In1| 06 CAP| 07 EDT|
1 ; would using square roots to form cos (a) from sin (a).
1 ; type is a program or an array.
1 ; statement, colour controls will be sent to it by mistake." - Steven Vickers
1 ; so 00 00 XX 00 00 (positive) or 00 FF XX FF 00 (negative).
1 ; mem-3 but that would spoil a good story and be slightly slower, as also
1 ; key is pressed.
1 ; i.e. integer indicator, sign byte, low, high, unused.
1 ; class-06 e.g. GOTO a*1000 ; a numeric expression must follow
1 ; a table using subtraction and minor manipulation.
1 ; ^ $27 $18 v
1 ; WORKSP STKBOT STKEND sp RAMTOP UDG P_RAMT
1 ; The ten single-character digit symbols are converted without the aid of
1 ; The ten keywords assigned to the digits in extended mode.
1 ; The ten control codes assigned to the top line of digits when the shift
1 ; The remaining red keywords below the keys.
1 ; The red keywords below keys on the original keyboard.
1 ; The green keywords on the original keyboard.
1 ; The colour system variable handler.
1 ; The 26 unshifted extended mode keys for the alphabetic characters.
1 ; The 26 shifted extended mode keys for the alphabetic characters.
1 ; The 26 red symbols assigned to the alphabetic characters of the keyboard.
1 ; Pitman Pocket Guide, 1984.
1 ; Lao Tze 604 - 531 B.C.
1 ; CHANS PROG VARS E_LINE WORKSP
1 ; <font color=#9900FF>Note.</font> that cos (a) could be formed here directly using 'cos' and stored in
1 ; "Each problem that I solved became a rule which served afterwards to solve
1 ; "A good calculator does not need artificial aids"
1 ; zero. The most likely explanation is that there were once separate end tests
1 ; zero if zero, with one if positive and with -minus one if negative.
1 ; y=sqr(1-x*x) - no need to multiply 1 by itself.
1 ; x-coordinate of this point measured from the centre of the circle is the
1 ; x coordinate to obtain a new fractional x-coordinate.
1 ; would reclaim any buffers associated with a stream. At least one has been
1 ; would just be a straight line. Eliminating this case here prevents
1 ; would be lost until eventually the draw coordinates might differ from the
1 ; with the manual (that says this is unused), the location has been used for
1 ; with closing the stream of that channel.
1 ; wishes to move the cursor down one line in edit mode.
1 ; will lead to either a system restart or the production of a strange report.
1 ; will give just the same result as
1 ; will calculate the address of the A'th entry, where each entry occupies
1 ; will be labelled terminating, absolute and start coordinates.
1 ; which may be in floating point or integer form, with the integer values
1 ; where it is going to stick the wanted value. The instruction LD DE, $0000
1 ; where dur = duration in seconds
1 ; when this is rotated out again then 8 bits have been read.
1 ; when the initial set carry is passed out again then a byte is complete.
1 ; when starting to read 8 bits the receiving byte is marked with bit at right.
1 ; when saving.
1 ; when it is set up to save the actual data.
1 ; when detecting a read-in signal on the tape.
1 ; when carry set then marker bit has been passed out and byte is complete.
1 ; when all bytes loaded then parity byte should be zero.
1 ; when a BASIC line is parsed.
1 ; well-used formula. Normally the rotation formula is used with the x and y
1 ; we could skip to normalize now but it's quicker to avoid normalizing
1 ; vertical arc draws one less than the perceived number of arcs.
1 ; variables.
1 ; variable pointed to <A href="#L121C">L121C</a> and that this enabled a Warm Restart to be
1 ; variable COORDS to ensure that drawing commences at the correct pixel.
1 ; values or section common code. The alternate register set is the only place
1 ; value in mem-1 is zero and the ry value in mem-2 is the full chord.
1 ; value for the attribute file and it is only necessary to manipulate H to
1 ; used to show type of arguments and result.
1 ; used to output a character in the A register so there is no need to
1 ; used to indicate which of the two passes is in effect and the carry
1 ; used by PRINT-FP.
1 ; updated.
1 ; up their two logarithms in the tables, added them together and then looked
1 ; two mantissas by setting the leftmost bit that is used for the sign.
1 ; twelve for LN and ATN. The mechanics of the routine are interesting but
1 ; trouble with expressions.
1 ; transfer sign of mantissa to Carry Flag.
1 ; to scale the coordinates of the first line which still points in the
1 ; to fetch the next immediate character following the current valid character
1 ; to enhance the text channel on the ZX Interface 1.
1 ; to decode the key values.
1 ; to be changed to match the BORDER colour.
1 ; to access system variables and flags so a user-written program must
1 ; to absolute coordinates by adding to the coordinates of the last point
1 ; times a second (sixty times a second in the USA ).
1 ; time the calculator stack is manipulated due to other activity on the
1 ; through an empty D.
1 ; through an angle, in radians, supplied by the third parameter.
1 ; this unnecessary alteration then there will be two blank lines between the
1 ; this table. The last byte of a token is inverted to denote the end of
1 ; this routine was indeed reversed but not as at first intended.
1 ; this entry point is when A holds $80 indicating a new variable.
1 ; this entry point is used to find a single edge from above but also
1 ; they could be present in a string expression, and in other situations.
1 ; these routines form the three simple results when the number is zero.
1 ; these routines are designed to work on either area.
1 ; there is enough space between the calculator stack and the machine stack
1 ; then decrease the counters within the two key-state maps
1 ; then both sets will be free.
1 ; then all 8 half-rows have been read. Shift is the first key to be
1 ; the word. The first is an inverted step-over byte.
1 ; the values obtained from this table.
1 ; the value 91 decimal.
1 ; the type is a numeric or string array.
1 ; the two numeric values, or the two string parameters, are on the
1 ; the time, it will now execute the code at 66 Hex.
1 ; the second set is always examined before the first.
1 ; the save loop begins by testing if reduced length is zero and if so
1 ; the same reason and to initialize the calculator stack at the start of
1 ; the same as used by ED-ERROR from which this has been augmented. The
1 ; the right place.
1 ; the reading of the EAR bit (D6) will always be preceded by a test of the
1 ; the output stream of the current channel. The alternate register set is
1 ; the outer loop is counted by H
1 ; the opportunity arose".
1 ; the lower screen/input buffer or the ZX printer.
1 ; the low byte of the Syntax table entry which was stored in T_ADDR.
1 ; the loading loop loads each byte and is entered at the mid point.
1 ; the length of the initial chord on a unary circle. This factor f is used
1 ; the last value is zero but no registers are altered.
1 ; the last relative y value (ry) used by DRAW.
1 ; the last point plotted that are required to get to the current point and
1 ; the jump will always be made to ARC-START.
1 ; the jump was to here with extended mode with uppercase A-Z.
1 ; the jump was here with mode = 0
1 ; the jump was here with digits, space, enter and symbol shift (< $xx)
1 ; the jump was here for tokens
1 ; the jump was here for other variables.
1 ; the input routine in use is the one for the keyboard.
1 ; the formula returns the next relative coordinates to use.
1 ; the first line will be drawn and how long it is and then the rotation
1 ; the final parity byte is saved reducing count to $FFFF.
1 ; the filename is more than ten characters in length or the null string.
1 ; the end points. The next pair will be the moving absolute values of x and y
1 ; the editor to highlight the error position if it occurred during syntax
1 ; the data itself is saved.
1 ; the current channel so the above two instructions are superfluous.
1 ; the command LOAD code may rejoin here with zero stacked as start.
1 ; the circle continues in an anti-clockwise direction. As noted earlier the
1 ; the character bitmaps so that they don't move as code is added and removed.
1 ; the central angle by the radius of the circle.
1 ; the case for the null string rejoins here.
1 ; the branch was here with an insertion or replacement point.
1 ; the branch was here with SAVE CODE start,
1 ; the branch was here with BASIC to consider an optional auto-start line
1 ; the branch was here when the location in workspace held a variable.
1 ; the branch was here when possibility of a '(' has been excluded.
1 ; the branch was here when first characters of name matched.
1 ; the branch was here to merge a program and its variables or an array.
1 ; the branch was here to consider auto-start.
1 ; the branch was here to consider a 'SCREEN$', the display file.
1 ; the branch was here to consider CODE.
1 ; the branch is here when two characters don't match
1 ; the branch is here when a program as opposed to an array is to be loaded.
1 ; the attributes for the lower lines are the same as upper ones and have
1 ; the arc is on a slope.
1 ; the angle 2 * PI radians which is 360 degrees.
1 ; the Z80's DJNZ instruction.
1 ; the Spectrum invokes machine code programs. This function returns the
1 ; the CALCULATE routine.
1 ; the 21 User Definable Graphics e.g.
1 ; the 'to_power' function. A cube root or indeed any root/power would be just
1 ; the 'IF' token and expression.
1 ; that this is perhaps not the best idea you've had that day.
1 ; that are updated after each line is drawn. The final pair will be loaded
1 ; tests repeated. CH_ADD will be addressing somewhere -
1 ; ten spaces are required for the default filename but it is simpler to
1 ; temporarily diverted to deal with, say colour control codes.
1 ; table to the routine that performs any ancillary actions associated
1 ; system variables area during E-LINE-NO; INT-TO-FP; stk-ten. In any case,
1 ; system variable that is updated above and if, as some have done, you make
1 ; subroutine that clears the lower display area. Note that at the moment
1 ; subroutine is on two occasions called directly when it is known that
1 ; streams 0 - 2 can't be closed as they are shared by the operating system.
1 ; straight lines - when drawn in any direction.
1 ; stored in the 'mem' locations. Some are not relevant for the circle.
1 ; stacking intermediate, unwanted constants onto a dummy calculator stack,
1 ; stacked.
1 ; stack in memory and conveniently DE which points to the first free byte
1 ; stack holds zero which is not very efficient as the test will always yield
1 ; stack always starts off as zero and the carry fed in determines if NOT is
1 ; square using 4 straight lines although very small circles are just drawn as
1 ; square root of a negative number generates an error in Sinclair BASIC.
1 ; spot so tidy the calculator stack and machine stack and plot the centre.
1 ; spaces may appear in variable names although the parser never sees them.
1 ; space key (D0), so store the initial post-test state.
1 ; sometimes red stripes on black paper just visible.
1 ; so the value of B denotes the state of the bit (two edges) read from tape.
1 ; so the same processing steps are used and then a final NOT is applied.
1 ; so that the exponent byte can be accessed for quick testing.
1 ; so a sixteen-bit register is required to store the length
1 ; so CHR$ 9 will only work if the next print position is at a newly
1 ; slightly displaced to the right.
1 ; six values are held in compressed format.
1 ; situation is that the lower screen is full and a rasp is given to suggest
1 ; simpler, than using LD (COORDS),HL.
1 ; simple addition and subtraction simplifying the navigational and
1 ; seventeen bytes of header data. It is also the exit route from that routine
1 ; series. As far as calculators are concerned, Chebyshev polynomials have an
1 ; sequence
1 ; selected for the editing area or workspace. The routines that call
1 ; screen in case the lower two lines have been extended upwards.
1 ; sample indicates we are in the middle of a two or five second lead-in.
1 ; sample 256 edges to check that we are in the middle of a lead-in section.
1 ; routines. The normal channel is $09F4.
1 ; routine.
1 ; rotated left to work up the left hand side and then down the right
1 ; right, the top angle is also (a/2) as angle BAE and EBA add to give a right
1 ; result is then doubled.
1 ; residue mod p.
1 ; require to draw a circle or arc - on paper!
1 ; repetitions of values like 3.49 would mean that the fractional parts
1 ; removing the possibility of any inaccuracy.
1 ; removed.
1 ; relevance to the BASIC parser. Otherwise CH_ADD is incremented and the
1 ; recursively to print tokens and the spaces associated with them.
1 ; read. The lower six bits of the shifts are unambiguous.
1 ; reach an approximation in just six iterations for SIN, eight for EXP and
1 ; re-initialize the system. All RAM above RAMTOP should, and will be,
1 ; radius.
1 ; radius and for an arc is the diameter with, as it happens, a pinch more if
1 ; radius 87. The Spectrum can attempt larger circles e.g. CIRCLE 0,14,255
1 ; radius 50 will have 24 straight lines but an arc of radius 50 will have 20
1 ; radians.
1 ; quadratic reciprocity says that if p and q are distinct odd primes, then
1 ; pseudo-register and makes consequential relative jumps just like
1 ; program has altered it.
1 ; professor of Geometry at Oxford University. These simplified the layout
1 ; produce two new x and y coordinates in an anticlockwise direction on the
1 ; process of drawing a large circle, free memory is checked 1315 times.
1 ; proceed with graphic codes.
1 ; proceed when the blue and yellow bands have been output.
1 ; preserved.
1 ; preserve any of the current main registers (HL, DE, BC).
1 ; present in the parameter table is also present in the correct
1 ; precise the space key is pressed during a tape operation.
1 ; plus etc. If either number is zero then this is flagged.
1 ; plotted. The first two values on the stack are the terminal tx and ty
1 ; plotted is saved as it will initialize the moving ax, value.
1 ; placing two zeros in the NMIADD system variable.
1 ; place.
1 ; picked up from a channel that has an open stream.
1 ; performed at any time, even while playing machine code games, or while
1 ; paths converge here and nothing must follow.
1 ; parameters can be derived from it, by a routine shared with DRAW.
1 ; p), so (75/65537) = (5/65537)^2 * (3/65537) = (3/65537). Now the law of
1 ; overwrite the first file-type indicator byte as well.
1 ; output will definitely be to the lower screen.
1 ; otherwise the variable was not found in run-time with SAVE/MERGE.
1 ; otherwise the long name matches in its entirety.
1 ; other purposes, then subsequent output to the printer buffer could corrupt
1 ; other problems" - Rene Descartes 1596 - 1650.
1 ; other paths rejoin here with BC holding length in range 1 - 10.
1 ; other characters irrelevant to the parsing of a BASIC line etc. .
1 ; or with input - INPUT, INKEY$ etc.
1 ; or the null string if false.
1 ; or more fully,
1 ; or both, is reached.
1 ; operator.
1 ; operations although the SUB 8 instruction does nothing useful and merely
1 ; operation and it handles normal completion with the restoration of the
1 ; only used to evaluate the number of straight lines and then discarded.
1 ; only is necessary. With anything less the second check only is required.
1 ; only if it's not a quadratic residue. For let w be a primitive root, d
1 ; once pointed to by the System Variable NMIADD. It would be essential that
1 ; once called from somewhere else in another context.
1 ; on whether the last test gave a true result.
1 ; on the circle. The periphery angle BAC is therefore a right angle by the
1 ; on address $0008 may page in a peripheral ROM such as the Sinclair
1 ; often used by third-party software.
1 ; of the tables enabling humans to easily scale calculations.
1 ; of the system variable NMIADD are zero or return if the location holds a
1 ; of the mathematical and string functions found in BASIC expressions.
1 ; of division then it can no longer be in integer form and the next re-stack
1 ; of NEW the supplied top value. The entire screen turns black with
1 ; number.
1 ; number or variable names match (zero flag set) then a replacement takes
1 ; number 9. The Napieran square root function is just a special case of
1 ; now use a variation of that formula to rotate the first arc through (A-a)/2
1 ; now the raw key (0-38d) is converted to a main key (uppercase).
1 ; now the new line or variable is entered.
1 ; now test if byte counter has reached $FFFF.
1 ; now send a sync pulse. At this stage mic is off and A holds value
1 ; now hold zero.
1 ; now enter a loop to merge the data block in workspace with the program and
1 ; now digits in 'KLC' mode
1 ; non-zero system variables and channel information. The A register flags
1 ; non-zero ones are all invertible. Hence under multiplication they form a
1 ; non-zero address. So attaching a simple switch to the NMI as in the book
1 ; nearest angle within reach is used.
1 ; naturally occurring number in branches of mathematics.
1 ; name for a number approximated to 2.718281828.
1 ; must have been symbol shift
1 ; must be found. The gap between two edges will be more for a '1' than a '0'
1 ; might have been to use end-calc; rst 08; defb 05.
1 ; middle of the arc-drawing loop. The arc count which includes the first
1 ; memory situation as we're just printing. The pitch and duration are exactly
1 ; may be supplied. This provides a user-friendly method of redefining
1 ; may alter that channel to divert subsequent RST 10 instructions to temporary
1 ; match or -128 for a type mismatch. Although characters have to be counted
1 ; makes b_i equal to n+1.
1 ; maintains the state of the bit to be saved.
1 ; machine stack.
1 ; lower screen and the upper screen areas which will also scroll wrongly.
1 ; long-term comparison byte containing both border colour and EAR bit.
1 ; locations below this.
1 ; location. Usually it stops when it reaches the top $FFFF, or in the case
1 ; location of the calculator stack or MEM area. The value one is written if
1 ; location following the command. For example, the 'THEN' token after
1 ; literals which are in range $80 - $FF.
1 ; lines of the display, setting attributes and correcting situations where
1 ; lines have been cleared, that any other lines take the permanent screen
1 ; like the ZX Spectrum that natural logarithms are once more at the fore,
1 ; keys and the space, ENTER and symbol shift key.
1 ; key values 0-39 else 255
1 ; its uses are for other channels.
1 ; it would be simpler all round if the routine just shoved unwanted values
1 ; it leads to division by zero when x is 1 or -1.
1 ; it all till it finds an unpopulated location or, less likely, a faulty
1 ; is used to find a single edge.
1 ; is unnecessary. Only the Sinclair ZX80 had integer division.
1 ; is the previously calculated, constant CENTRAL ANGLE of the arcs.
1 ; is syntactically incorrect and not really desirable.
1 ; is set then data is loaded, if reset then it is verified.
1 ; is made to MAIN-4, etc. to handle the error.
1 ; is indexed to provide an offset to the handling routine that
1 ; is encountered after the keyword.
1 ; is drawn, they are not shown until then.
1 ; is a primitive root modulo 65537.
1 ; is a cyclical sequence of p-1 distinct numbers in the range 0 to 1
1 ; is 4 (as set up by the CD_PARAMS routine) and so the zero flag will never
1 ; inverted end-marker of the previous entry in the table.
1 ; into the COORDS system variable so that the first vertical line starts at
1 ; internal language.
1 ; intended to work the other way. Sinclair Research said that, since they
1 ; integer or floating point, on calculator stack.
1 ; intact.
1 ; instead of the more expensive 'cos' function.
1 ; instead of being used as destination variables.
1 ; inscribed angle (a/2) is half the central angle (a).
1 ; input workspace.
1 ; inoperable. Similarly PUSH and CALL instructions cannot be used to store
1 ; initialization. It's new location is after the system variables and is
1 ; in which case another edge should appear before B rises to $FF
1 ; in this ROM and within 256 bytes of the close stream look up table that
1 ; in the first five bytes of ROM. The destination DE normally points to the
1 ; in the case of a CIRCLE or to the calculated end point in the case of
1 ; in the accumulator.
1 ; in run-time there are two 16-bit parameters on the calculator stack.
1 ; in a Warm Restart scenario, to produce a report code, leaving any program
1 ; if they measure up to anything significant.
1 ; if there are more characters after CODE expect start and possibly length.
1 ; if the numeric argument were printed.
1 ; if the number was zero (false) then the null string must be returned by
1 ; if the keyboard has not been pressed during the last five interrupts
1 ; if ten characters matched and the types previously matched then C will
1 ; if not consider the second key map.
1 ; if it was any other value.
1 ; if coming from START or NEW.
1 ; if a string expression preceded the '(' then slice it.
1 ; i.e. abort the KEYBOARD call.
1 ; horizontal lines at the top and bottom. The number of lines is calculated
1 ; here to calculate the next coordinate using the ROTATION FORMULA where (a)
1 ; header or to $FF for data. IX points to the start of receiving location
1 ; having excluded a repeating key we can now consider a new key.
1 ; have been implemented inline. On the ZX81, this calculator routine was also
1 ; hand side of the keyboard. When the reset bit drops into the carry
1 ; had never advertised the NMI, they had no plans to fix the error "until
1 ; group (Fp*, say) of order p-1; moreover (and not so obvious) Fp* is cyclic.
1 ; graphics mode with digits
1 ; give the starting y coordinate sy.
1 ; from the radius of the circle and is always divisible by 4. For complete
1 ; from the initial sx and sy values which are kept at the base of the
1 ; from the 2nd RRCA is, as before, fed into the first of the end tests but
1 ; from BEEP, to stack an entry in the semi-tone table. It is not part of the
1 ; from the current input channel.
1 ; four of the other mem locations by the CIRCLE DRAW PARAMETERS routine which
1 ; formula takes over and calculates all other rotated points.
1 ; form the correct colour attribute address.
1 ; for verification the byte read from tape is compared with that in memory.
1 ; for the result in a table of antilogarithms to give the desired product.
1 ; for the duration of the routine.
1 ; for numbers and strings.
1 ; for mic on.
1 ; for keys '0' - '7' we assign a mosaic character depending on shift.
1 ; for full treatment of how these are generated with demonstrations in
1 ; for any subsequent LDIR.
1 ; for another five-byte value. It returns with BC holding the value 5 ready
1 ; for LOAD/VERIFY put zero on stack to signify handle at location saved from.
1 ; follows the table.
1 ; followed by an 8-bit displacement, from that byte's address in the
1 ; followed by a '(' then the numeric expression is complete.
1 ; floating-point numbers in the calculator's memory area.
1 ; floating point values used above by several pixels.
1 ; floating point form. HL points to first byte.
1 ; floating point form inserted after that. Similar invisible value holders
1 ; five bytes. It is used for reading the semi-tone table and addressing
1 ; finally flags set or reset if necessary.
1 ; fairly random.
1 ; factor of 65536: hence w^{32768*r} = 1 (mod p), so 65536 divides 32768*r,
1 ; example, when '#' is encountered with output - PRINT, LIST etc.
1 ; errors have occurred while the normal input and output routines have been
1 ; end of the calculator stack which might be in the normal place or in the
1 ; else the destination is the first dimension within the array structure
1 ; else print a terminal carriage return.
1 ; else is data bytes and a shorter lead-in is used.
1 ; else force division by zero thereby raising an Arithmetic overflow error.
1 ; else entire variables area has to be searched.
1 ; else delete the top two stack values and draw a simple straight line.
1 ; else continue into VERIFY control routine to verify.
1 ; else allow saved code to be loaded to a specified address.
1 ; else all possibilities have been considered and nothing must follow.
1 ; else X is non-zero. Function 'ln' will catch a negative value of X.
1 ; else A indicates type 0-3.
1 ; earlier to print mosaic characters.
1 ; each section.
1 ; e.g. from mult when integer multiplication has overflowed.
1 ; e.g. cp 'V'; jr c,addit; pop af ;pop af ;;addit etc. (6 extra bytes).
1 ; e.g. We know the opposite side (x) and hypotenuse (1)
1 ; e.g. VAL$ (z$+"(2)") = a$(2) if z$ happens to be "a$".
1 ; e.g. VAL "2.3" = 2.3, VAL "2+4" = 6, VAL ("2" + "4") = 24.
1 ; e.g. STR$ (1/10) produces "0.1".
1 ; e.g. PRINT PAPER 2; CHR$ 9; AT 4,0;
1 ; e.g. NOT 0 returns 1, NOT 1 returns 0, NOT -3 returns 0.
1 ; e.g. CODE "Aardvark" = 65, CODE "" = 0.
1 ; e.g. (STR$ PI) (3 TO) (TO 2) or "nonsense" (4 TO )
1 ; e.g. "You Win" AND score>99 will return the string if condition is true
1 ; e.g. -3 AND 2 returns -3.
1 ; during the one-second gap following the header on tape.
1 ; down in memory. The table is never searched, by this ROM, and the last
1 ; doing it this way makes the circle slightly larger.
1 ; does work but is not very helpful"
1 ; does not divide d) as +1 or -1, according as d is or is not a quadratic
1 ; division by zero at later stage.
1 ; disable interrupts to make use of the IY register.
1 ; direction of the end point and may be larger.
1 ; difference was zero and false with anything else.
1 ; devised, in conjunction with Napier, by Henry Briggs a Cambridge-educated
1 ; defined place.
1 ; current background colour.
1 ; credit: Martin Wren-Hilton 1982.
1 ; cos a = 1 - 2 * sin(a/2) * sin(a/2)
1 ; cos (a) = 1 - 2 * sin(a/2) * sin(a/2).
1 ; copied from ROM to the STRMS system variables area during initialization.
1 ; coordinates. The x-coordinate is converted first but first the last point
1 ; coordinates required by the DRAW routine.
1 ; coordinates have the integer coordinates of the last plot position
1 ; coordinates from the centre of the circle (or arc) and a supplied angle to
1 ; converting a number in the range 0-255 to a string e.g. CHR$ 65 = "A".
1 ; convenient resting place for DATADD.
1 ; continue with extended digits 0-9.
1 ; continue with SAVE/LOAD/VERIFY SCREEN$.
1 ; continue with SAVE/LOAD DATA
1 ; continue with SAVE, LOAD, MERGE of DATA.
1 ; continue with LOAD, MERGE, VERIFY and also SAVE within ten character limit.
1 ; continue with LOAD, MERGE and VERIFY.
1 ; continue when data type matches.
1 ; continue when HL addresses a BASIC line number.
1 ; continue to save program and any variables.
1 ; continue to consider DATA.
1 ; continue or jump to here if one of the buffers was free.
1 ; continue in runtime.
1 ; continue in run-time to save BASIC without auto-start.
1 ; continue after delay with H holding zero and B also.
1 ; context. This could be a keyword and, with the exception of NOT a repeat
1 ; contents of the BC register pair.
1 ; contains an offset to the second byte of a channel. The first byte of a
1 ; congruent to w^r (mod p). If d is not primitive, then its order is a proper
1 ; concept and not all errors pass through here.
1 ; comparisons. On entry, the calculator literal is in the B register and
1 ; compared by comparing every character until a mismatch, or the end of one
1 ; command which stacks the origin of the circle (X,Y).
1 ; command entry point.
1 ; code then a decision would have to be made at this point to jump forward,
1 ; closing straight line is drawn at ARC_END, but it otherwise loops back to
1 ; clever trick 'cos' is derived from 'sin' using simple arithmetic operations
1 ; circumference of the circle.
1 ; circles it will range from 4 for a square circle to 32 for a circle of
1 ; chip's JR instruction.
1 ; checking. It is used at 37 places in the program. An instruction fetch
1 ; characters to be counted. The characters must be shown on the screen.
1 ; character, which could be anything other than a comma, provides a
1 ; character 144.
1 ; channel can't be used as that would result in an offset of zero for some
1 ; channel area using the system variable CURCHL.
1 ; centre, or origin, D. Line BC is the diameter of length 2 and A is a point
1 ; centre is (a).
1 ; cassette handling routines in this ROM.
1 ; carry is set on entry else zero.
1 ; can be removed.
1 ; can be mapped to 256 input characters
1 ; can be deleted to expose the closing coordinates.
1 ; called repeatedly to step along the line. It is used 83 times.
1 ; called at the previous instruction.
1 ; call the two bits are XORed to form the result sign - minus * minus giving
1 ; calculator suite of routines. On entry, HL points to the number to be
1 ; calculator stack.
1 ; calculator stack.
1 ; calculator stack throughout the arc loop.
1 ; calculator stack for safe keeping.
1 ; calculated as X+Y rather than by Pythagoras Theorem and the sine of the
1 ; c are also equal. If b+c+c = 180 degrees and b+a = 180 degrees then c=a/2.
1 ; by calls to the DRAW-LINE routine.
1 ; but we could have just symbol shift and no other
1 ; but these will error as they go off-screen after four lines are drawn.
1 ; but the program line or variable matches so old one is reclaimed.
1 ; but no more than ten characters are allowed for SAVE.
1 ; but long-named variables have to be matched character by character.
1 ; but if it is the wildcard, then add ten to C which is minus ten for a type
1 ; but if found in table the priority has to be looked up.
1 ; but if bit is 1 then the mic state is held for longer.
1 ; but continue when a transition is found on tape.
1 ; but an edge, a transition of the EAR bit, has been found so switch the
1 ; but a short gap will be the sync pulse.
1 ; branch here when variable is to replace an existing one
1 ; border and also abnormal termination when the break key, or to be more
1 ; bit 7 of C will not alter from state set here.
1 ; between workspace and the calculator stack.
1 ; below.
1 ; below the space character.
1 ; beginning - see accompanying documentation.
1 ; begin by testing for a shift with no other.
1 ; begin by deleting the known zero to leave Y the power factor.
1 ; be set and the loop is always entered. The first test is superfluous and
1 ; be drawn by joining the last point plotted to the initial start point
1 ; available to store 3 persistent 16-bit system variables.
1 ; attributes.
1 ; at offset x,y using the LINE-DRAW routine.
1 ; at line 4000, or indeed, at all.
1 ; astronomical calculations which beset his age.
1 ; assume upper screen in use and thus optimize for path that requires speed.
1 ; asn(a) = atn(x/sqr(1-x*x))
1 ; as this could cause one to become free.
1 ; as simple.
1 ; as opposed to, say, LOAD 'x' CODE 32768,300.
1 ; as a tangent, taking the radius as its distance from the centre.
1 ; are the squares in Fp*, and the "Legendre symbol" (d/p) is defined (when p
1 ; are now brought into play.
1 ; are also created after the numeric and string variables in a DEF FN list.
1 ; are adjacent (or the same) but is probably best dispensed with.
1 ; arc will form part. This value does not have to be too accurate as it is
1 ; applied to it. So the only time the greater-0 test is applied is if the
1 ; any variables within braces will be treated as part, or all, of the prompt
1 ; any NMI Handler would perform the tasks from here to the EI instruction
1 ; another Spectrum has been allowed to gain control of this one.
1 ; angle as do BAE and EAC.
1 ; and zero is used to denote that a stream is closed.
1 ; and we wish to find angle a in radians.
1 ; and the last absolute values of x and y
1 ; and make it more readable, it can also be used for the opposite effect and
1 ; and lower screen or, if the printer is in use, the column position and
1 ; and hence r is even and d is a square (mod p). Conversely, the squares in
1 ; and for streams 0 - 3 just enter the initial data back into the STRMS entry
1 ; and determine also the number of straight lines from that value and the
1 ; and cosine are pre-calculated and held in the mem locations. As a
1 ; and by picking any two numbers, 1.72 and 6.89 say,
1 ; and HL holds its address which will not be within quoted text
1 ; and Dr Frank O'Hara, published 1983 by Melbourne House.
1 ; and DE holds the length of bytes to be loaded. If, on entry the carry flag
1 ; an invisible chr 14d inserted after them and the 5-byte integer or
1 ; an ARC.
1 ; although some computers retain logarithms to the base ten.
1 ; alters the string test bit.
1 ; altering the length of the string on the calculator stack to zero.
1 ; also returns the number of straight lines in the B register.
1 ; along the way it gets modified by the comparison process. The result on the
1 ; allocated the local currency symbol for the relevant country -
1 ; after each line is drawn. Since we are drawing a vertical line then the rx
1 ; advantage over other series, for example the Taylor series, as they can
1 ; addresses the exponent of the test value.
1 ; addressed by the system variable CHANS which means that it can slide up and
1 ; address to be updated by PRINT or PLOT.
1 ; address of the User Defined Graphic character that is in the string.
1 ; address and update the associated system variable.
1 ; accurate, absolute coordinates maintained in ax and ay and these new
1 ; absolute memory address.
1 ; above conditions so this path is never taken.
1 ; a value 0-9.
1 ; a string expression and allow it to be sliced. If a numeric expression is
1 ; a period of mic off with yellow border.
1 ; a length on tape shorter than expected is not allowed for CODE
1 ; a final value 1 (true) or 0 (false).
1 ; a dot on the screen.
1 ; a BASIC line. It is also called to stack a numeric variable value, and
1 ; a 256-byte section of memory.
1 ; ZASM (MacOs) cross-assembler directives. (uncomment by removing ';' )
1 ; With two parameters, it simply draws an approximation to a straight line
1 ; With three parameters, an arc is drawn to the point at offset x,y turning
1 ; With the factor stored, scale the x coordinate first.
1 ; With INPUT LINE, this key must be used instead of entering STOP.
1 ; While PRINT ATN (x/SQR (1-x*x)) gives the same results as PRINT ASN x,
1 ; When the NMI line is held low, then no matter what the Z80 was doing at
1 ; When drawing a large arc, free memory is checked 928 times.
1 ; When a BASIC LINE or the INPUT BUFFER is parsed any numbers will have
1 ; What is being used here, instead, is the relative X and Y parameters from
1 ; Weird, but necessary, if saving to sectors.
1 ; We now want three copies of this pair of values on the calculator stack.
1 ; We can derive length y by Pythagoras and then use ATN instead.
1 ; VAL$ treats the characters in a string as a string expression.
1 ; VAL treats the characters in a string as a numeric expression.
1 ; Using shift keys and a combination of modes the Spectrum 40-key keyboard
1 ; Uses an adaptation of the formula asn(x) = atn(x/sqr(1-x*x))
1 ; Use this, & Gauss' law of quadratic reciprocity, to show that 75
1 ; Use the exponent manipulating trick again to double the value of mem-2.
1 ; Unshifted alphabetic keys have $20 added to the value.
1 ; Unary so on entry HL points to last value, DE to STKEND.
1 ; Unary follow.
1 ; Typically, a Spectrum will have 16K or 48K of RAM and this code will test
1 ; Typically with PRINT USR 0.
1 ; To recap the full calculator stack is tx, ty, ax, ay.
1 ; To raise a number to the power 3, find its 'ln', multiply by 3 and find the
1 ; To overcome this, 1 is added to y giving half the required angle and the
1 ; To move n octaves higher or lower, frequencies are multiplied by 2^n.
1 ; Three pseudo binary operations first.
1 ; This table contains an entry for a letter found in the CHANS area.
1 ; This subroutine is used by the ROM to open a channel 'K', 'S', 'R' or 'P'.
1 ; This subroutine is called once from the keyboard INPUT command to check if
1 ; This subroutine is called once from RST 18 to skip over white-space and
1 ; This subroutine is called from RST 20, and three times from elsewhere
1 ; This subroutine deals with the input items and print items.
1 ; This single operation is used, in the first instance, to evaluate most
1 ; This section deals with the upper screen.
1 ; This section deals with the lower screen.
1 ; This section applies to START only.
1 ; This routine, when supplied with a base address in HL and an index in A,
1 ; This routine which is part of PRINT-OUT allows RST $10 to be used
1 ; This routine updates the system variables associated with the main screen,
1 ; This routine traverses variable-length entries in the table of constants,
1 ; This routine swaps the last two values on the calculator stack.
1 ; This routine saves a section of data. It is called from SA-CTRL to save the
1 ; This routine replaces the last value on the calculator stack,
1 ; This routine removes these 'compiled' numbers from the edit line or
1 ; This routine re-stacks an integer, usually on the calculator stack, in full
1 ; This routine places an integer value of zero or one at the addressed
1 ; This routine is used when it is inconvenient to save these values at the
1 ; This routine is used to print any character in range 32d - 255d
1 ; This routine is used to load bytes and on entry A is set to $00 for a
1 ; This routine is entered with the HL register holding the last screen
1 ; This routine is called to stack a hidden floating point number found in
1 ; This routine is called to re-stack two numbers in full floating point form
1 ; This routine is called once to verify that the mandatory separator
1 ; This routine is called on five occasions to print the ASCII equivalent of
1 ; This routine is called in succession from multiply and divide to prepare
1 ; This routine is called from MOVE-FP, STK-CONST and STK-STORE to test that
1 ; This routine is called from INPUT, and from the MAIN execution loop.
1 ; This routine is called from 3 places other than above to load a data block.
1 ; This routine is also used to terminate the VAL and READ-IN routines for
1 ; This routine is also called directly from the end-tests of the comparison
1 ; This routine increments the Spectrum's three-byte FRAMES counter fifty
1 ; This routine fetches the line/column and display file address of the upper
1 ; This routine fetches the address of the input stream from the current
1 ; This routine fetches a filename in ZX81 format and is not used by the
1 ; This restart is used on only 12 occasions to create BC spaces
1 ; This restart is used 21 times.
1 ; This restart enters the Spectrum's internal, floating-point, stack-based,
1 ; This overwrites the last value with 1 if it was zero else with zero
1 ; This moves the print position to the right leaving a trail in the
1 ; This location can also be 'called' to reset the machine.
1 ; This literal combines two strings into one e.g. LET a$ = b$ + c$
1 ; This is very much a housekeeping routine which clears between 2 and 23
1 ; This is the single entry point for the four tape commands.
1 ; This is the routine most often used by the RST 10 restart although the
1 ; This is the initial stream data for the seven streams $FD - $03 that is
1 ; This is the error routine addressed by ERR_SP. This is not for the out of
1 ; This is the calculator literal used by the INKEY$ function when a '#'
1 ; This is quicker than multiplying by four.
1 ; This is either for its own use or in response to a user's request, for
1 ; This initial channel information is copied from ROM to RAM, during
1 ; This function returns the contents of a memory address.
1 ; This function returns a single character string that is a result of
1 ; This function reads a byte from an input port.
1 ; This function produces a string comprising the characters that would appear
1 ; This formula forms cos(a) from sin(a/2) using simple arithmetic.
1 ; This entry point prints the BASIC keywords, '<>' etc. from alt set
1 ; This entry point is used to print tape, boot-up, scroll? and error messages.
1 ; This entry point entered from above to print ASCII and UDGs but also from
1 ; This ensures that the final line finishes exactly at the starting pixel
1 ; This enables the calculator to perform relative jumps just like the Z80
1 ; This enables the calculator to perform conditional relative jumps dependent
1 ; This command allows streams to be closed after use.
1 ; This can also be expressed as 1-length CE. Examining the triangle at the
1 ; This calculator literal finds the absolute value of the last value,
1 ; This branch is used to update the printer position by 32 places
1 ; This branch is taken when the command is LOAD with type 0, 1 or 2.
1 ; This branch is taken from above and from RST 00h.
1 ; This Interrupt Service Routine will jump to location zero if the contents
1 ; These two nested routines ensure that the appropriate pointers are
1 ; These six look-up tables are used by the keyboard reading routine
1 ; These routines begin with the service routines followed by a single
1 ; There is nowhere to store values in RAM or on the stack which becomes
1 ; There is not much point in coming here.
1 ; There is no NMI switch on the standard Spectrum or its peripherals.
1 ; There are two parameters e.g. DRAW 255,175
1 ; There are two branches to this routine.
1 ; There are some one and two-byte alternatives but perhaps the most formal
1 ; There are reserved locations there for another 12 streams. Each location
1 ; Then if b_i is the residue of a^i modulo p (1<=b_i<p-1), the
1 ; The various control routines for LOAD, VERIFY and MERGE are executed
1 ; The values cos(a) and sin(a) are pre-calculated and held in mem-3 and mem-4
1 ; The user function with a one-character string argument, calculates the
1 ; The two parameters of the two strings to be combined are on the stack.
1 ; The tokenized characters 134d (RND) to 255d (COPY) are expanded using
1 ; The third parameter is 2*PI (or a multiple of 2*PI) so a 360 degrees turn
1 ; The tabular use of logarithms was that to multiply two numbers one looked
1 ; The table doesn't require a zero end-marker as the letter has been
1 ; The subroutine is also called directly from the end-tests of the comparison
1 ; The starting point is at the base of this chord which is drawn upwards and
1 ; The routine prints to the current channel and the printing of control codes
1 ; The routine first determines in what context it has been called by examining
1 ; The radius/diameter is left on the calculator stack.
1 ; The purpose was once to find the offset to a special closing routine,
1 ; The previous 32 function-type words are printed without a leading space
1 ; The parameters of the DRAW command were relative and they are now converted
1 ; The parameters derived from mem-5 (A) and from the radius are set up in
1 ; The next test avoids drawing 4 straight lines when the start and end pixels
1 ; The next step calculates (roughly) the diameter of the circle of which the
1 ; The neat arrangement of ports means that the B register need only be
1 ; The moving absolute values of x and y are no longer required and they
1 ; The mid entry point.
1 ; The last-character-inverted Cassette messages.
1 ; The last location of the key map holds the decoded key from the first
1 ; The keywords for the main alphabetic keys are obtained by adding $A5 to
1 ; The keys consist of the 26 upper-case alphabetic characters, the 10 digit
1 ; The inverse sine function with result in radians.
1 ; The individual bits of the literal are manipulated to group similar
1 ; The function RND involves replacing b_i-1 in memory by b_(i+1)-1,
1 ; The following have a leading space if they begin with a letter
1 ; The following are just the next available slots for the 128 compound
1 ; The first three numeric comparisons are just the opposite of the last three
1 ; The first ten characters of any other command parameter are acceptable.
1 ; The first table contains the maps for the 39 keys of the standard
1 ; The first pair remain on the stack throughout the circle routine and are
1 ; The first of these service routines is a curiosity.
1 ; The first entry point looks for two adjacent edges. The second entry point
1 ; The first chord drawn is the vertical chord on the right of the circle.
1 ; The final arc offsets are obtained by subtracting the final COORDS value
1 ; The figure shows a right triangle that inscribes a circle of radius 1 with
1 ; The exponential function EXP x is equal to e^x, where e is the mathematical
1 ; The error pointer is made to point to the position of the error to enable
1 ; The error code is stored and after clearing down stacks, an indirect jump
1 ; The entry point to save yellow part of bit.
1 ; The entry point to save 1 entire bit. For first bit B holds $3B(*).
1 ; The entry point TEMP-PTR1 is used from the SCANNING routine.
1 ; The entire address space can be peeked including the ROM.
1 ; The end-calc literal terminates a mini-program written in the Spectrum's
1 ; The cosine of (a) is the length DE as the hypotenuse is of length 1.
1 ; The contents of the location currently addressed by CH_ADD are fetched.
1 ; The common code tests RAM and sets it to zero re-initializing all the
1 ; The calculator has an instruction that decrements a single-byte
1 ; The backfill loop is entered at midpoint and ensures, if more than 2
1 ; The arc will consist of 4 to 252 straight lines each one of which is drawn
1 ; The arc is greater than 0.5 so the circle can be drawn.
1 ; The arc drawing loop will draw up to 31 straight lines for a circle and up
1 ; The address of this routine is pushed on the stack prior to any load/save
1 ; The accumulator is set to $00 for a header, $FF for data.
1 ; The above map may help in reading.
1 ; The ZX81 ROM used PRINT EXP ( LN 9 / 2 ) to find the square root of the
1 ; The USR function followed by a number 0-65535 is the method by which
1 ; The Spectrum's DRAW command is overloaded and can take two parameters sets.
1 ; The Spectrum uses Interrupt Mode 1.
1 ; The Spectrum uses Chebyshev polynomials to generate approximations for
1 ; The Spectrum screen arrangement leads to the L register holding the correct
1 ; The Spectrum Input character keys. One or two are abbreviated.
1 ; The Spectrum DRAW routine draws to the rounded x and y coordinate and so
1 ; The NEW command path rejoins here.
1 ; The NEW command is about to set all RAM below RAMTOP to zero and then
1 ; The L register has been loaded with the report code but X-PTR is not
1 ; The EXP function is the BASIC equivalent of a calculator's 'antiln' function
1 ; The CIRCLE command makes extensive use of the calculator and as part of
1 ; The CIRCLE command draws a circle as a series of straight lines.
1 ; The CIRCLE and ARC-DRAW commands converge here.
1 ; The Boolean AND operator.
1 ; The BASIC lines are displayed at the top of the screen and the user
1 ; The B register holds a count, up to 256, within which the edge (or edges)
1 ; The ARC will consist of multiple straight lines so call the CIRCLE-DRAW
1 ; The A register holds the code of the character that is to be sent to
1 ; The 'x>y' example is the easiest as it employs straight-thru logic.
1 ; That is, PRINT ATN (x/(SQR (1-x*x) +1)) *2
1 ; Test the angle for the special case of 360 degrees.
1 ; Test if top value on calculator stack is zero. The carry flag is set if
1 ; Test if the last value on the calculator stack is greater than zero.
1 ; THE GEOMETRIC PROOF OF FORMULA cos (a) = 1 - 2 * sin(a/2) * sin(a/2)
1 ; Subtracting $EO (the present arrangement) gives a value of
1 ; Subtract the length of the half-chord from the absolute y coordinate to
1 ; String comparisons are a little different in that the eql/neql carry flag
1 ; Strictly speaking, the radius should be multiplied by cos(a/2) first but
1 ; Store the last point plotted to initialize the moving ay value.
1 ; Store the last point plotted to initialize the moving ax value.
1 ; Store the absolute ay in temporary variable mem-0 for the moment.
1 ; Starts with normal initial step-over byte.
1 ; Starts with binary operations which have two operands and one result.
1 ; Software houses would have been able to protect their games from attack by
1 ; So, asn(a) = atn(x/y)
1 ; So that simple arithmetic can be used, the length of the chord can be
1 ; So cos (a) = 1 - AC * sin(a/2)
1 ; Sinclair BASIC see "The Complete Spectrum ROM Disassembly" by Dr Ian Logan
1 ; Since y*y + x*x = 1*1 (Pythagoras Theorem) then
1 ; Since the vertex of the largest triangle B touches the circle, the
1 ; Since the initial sx and sy values are not required until the final arc
1 ; Since a string slice can itself be sliced then loop repeatedly
1 ; Similarly to find the n'th root divide the logarithm by 'n'.
1 ; Similar to FORTH's 'divide mod' /MOD
1 ; SIN, ATN, LN and EXP. These are named after the Russian mathematician
1 ; Rule of Thales.
1 ; Returns the length of a string.
1 ; Returns the ASCII code of a character or first character of a string
1 ; Returns 1 or 2 keys in DE, most significant shift first if any
1 ; Remove the now redundant diameter value D.
1 ; Register DE is set to STKEND and HL, the result pointer, is set to five
1 ; Register A contains the message number, often zero to print first message.
1 ; RANDOM THEORY from the ZX81 manual by Steven Vickers
1 ; Pafnuty Chebyshev, born in 1821, who did much pioneering work on numerical
1 ; PRINT-A-2 is a continuation of the RST 10 restart that prints any character.
1 ; POKE USR "a", BIN 10000000 will put a dot in the top left corner of the
1 ; PARAMETERS ROUTINE to pre-calculate sine values from the angle (in mem-5)
1 ; Overwrite registers with values for lower screen.
1 ; Originally IX addresses first location and only one header is required
1 ; Once we get the coordinates of the first straight line then the 'ROTATION
1 ; On the first call A holds zero and picks up the sign bit. On the second
1 ; On the Spectrum, this is only used internally by the RND function and could
1 ; On later Amstrad-made Spectrums, and the Brazilian Spectrum, the logic of
1 ; On exit, HL=result, DE=stkend.
1 ; On entry, as always with binary operations,
1 ; On entry, HL points to the exponent the first byte of the value.
1 ; On entry the DE register points to an initial step-over byte or the
1 ; On entry -
1 ; OLD NEW PROG DATA DATA CODE
1 ; Numeric Comparisons.
1 ; Numbers are compared by subtracting one from the other, strings are
1 ; Number y is subtracted from x and the result tested for greater-0 yielding
1 ; Now the initial x and y coordinates are made positive and summed to see
1 ; Now test every edge looking for the terminal sync signal.
1 ; Now store this important constant in mem-5 and delete so that other
1 ; Now scale the y coordinate.
1 ; Now save the rest of the main registers and read and decode the keyboard.
1 ; Now reduce the low byte of the Syntax table entry to give command.
1 ; Now make the radius positive and ensure that it is in floating point form
1 ; Now form cos(a) from sin(a/2) using the 'DOUBLE ANGLE FORMULA'.
1 ; Now enter the calculator and store the complete rotation angle in mem-5
1 ; Now add the fractional relative x coordinate to the fractional absolute
1 ; Note that for simplicity, Sinclair have located all the control codes
1 ; Note that for a circle this is also the end coordinate.
1 ; Non-standard entry points have a label beginning with X.
1 ; Next simply add the radius to the x coordinate to give a fuzzy x-coordinate.
1 ; Next calculate the relative y coordinate to the end-point.
1 ; Next calculate the length of half a chord by multiplying the sine of half
1 ; Natural logarithms were devised in 1614 by well-traveled Scotsman John
1 ; Napier's logarithms were quickly overtaken by logarithms to the base 10
1 ; Napier's logarithms enabled the above operations to be accomplished by
1 ; Napier who noted
1 ; Napier also mentioned "square and cubicle extractions".
1 ; NUMBER OF STRAIGHT LINES = ANGLE OF ROTATION * SQUARE ROOT ( Z ) / 2
1 ; More specifically a change in bit 6 of value input from port $FE.
1 ; Memory location mem-1 holds the last relative x value (rx) and mem-2 holds
1 ; Magically, the two new rotated coordinates rx and ry are all that we would
1 ; Looking at the largest triangle, side AC can be expressed as
1 ; Locations mem-1 and mem-2 are the relative x and y values which are updated
1 ; Line AC is a chord touching two points on the circle and the angle at the
1 ; Like 'pi' also, 'e' is an irrational number and starts 2.718281828...
1 ; Let p be a [large] prime, & let a be a primitive root modulo p.
1 ; Keyboard input has been made and it remains to adjust the upper
1 ; Just as one would do if drawing the curve on paper, the final line would
1 ; Its generators are the "primitive roots". The "quadratic residues modulo p"
1 ; It is used on 77 occasions.
1 ; It is this routine that helps make the variables 'Anum bEr5 3BUS' and
1 ; It is only recently with the introduction of pocket calculators and machines
1 ; It is only necessary to place the values (sx) and (sy) in the system
1 ; It is only called from the above INPUT routine but was obviously
1 ; It is only called from PO-ABLE which continues into PO-STORE
1 ; It is not possible to use this routine for the table of constants as these
1 ; It is highly likely that the first check was written by Steven Vickers.
1 ; It is further used recursively from within the calculator.
1 ; It is entered with a system stream $FD - $FF, or a user stream $00 - $0F
1 ; It is called on three occasions when the value of DE must be preserved.
1 ; It is always a good idea to anchor, using ORGs, important sections such as
1 ; It can be deduced by looking elsewhere in this ROM that the NMIADD system
1 ; Interface 1 or Disciple Disk Interface. This was not an original design
1 ; Initially, the syntax has been partly checked using the class for the DRAW
1 ; Initially the A register holds the character to be considered
1 ; In the case when p = 65537, we can show that d is a primitive root if and
1 ; In some ways it can be regarded as a polygon, but the first line is drawn
1 ; In all cases the accumulator is first set to $FF so the routine could be
1 ; In Sinclair BASIC strings can be more than twenty thousand characters long
1 ; If, as suggested above, the NMI service routine pointed to this section of
1 ; If the user typed 40000 instead of 4000 then it won't auto-start
1 ; If the literal has to be also usable as a function then bits 6 and 7 are
1 ; If the first line is less than .5 then 4 'lines' would be drawn on the same
1 ; IX-$11 IX+$00 0 1 2 3 Type.
1 ; IX-$10 IX+$01 x x x x F ($FF if filename is null).
1 ; IX-$0F IX+$02 x x x x i
1 ; IX-$0E IX+$03 x x x x l
1 ; IX-$0D IX+$04 x x x x e
1 ; IX-$0C IX+$05 x x x x n
1 ; IX-$0B IX+$06 x x x x a
1 ; IX-$0A IX+$07 x x x x m
1 ; IX-$09 IX+$08 x x x x e
1 ; IX-$08 IX+$09 x x x x .
1 ; IX-$07 IX+$0A x x x x (terminal spaces).
1 ; IX-$06 IX+$0B lo lo lo lo Total
1 ; IX-$05 IX+$0C hi hi hi hi Length of datablock.
1 ; IX-$04 IX+$0D Auto - - Start Various
1 ; IX-$03 IX+$0E Start a-z a-z addr ($80 if no autostart).
1 ; IX-$02 IX+$0F lo - - - Length of Program
1 ; IX-$01 IX+$10 hi - - - only i.e. without variables.
1 ; IX points to start of descriptor.
1 ; IX points to descriptor.
1 ; INKEY$ # does not interact correctly with the keyboard, #0 or #1, and
1 ; Holds frequencies corresponding to semitones in middle octave.
1 ; Hence to check whether 75 is primitive mod 65537, we want to calculate that
1 ; Hence (3/65537) = (65537/3) * (-1)^{65536*2/4} = (65537/3)
1 ; Having cleared all 24 lines of the display area, continue into the
1 ; Having calculated the x value for DRAW do the same for the y value.
1 ; HL=first number, DE=second number
1 ; HL=destination
1 ; HL addresses the exponent.
1 ; HEADER HEADER num chr NOTES.
1 ; Graphically it is a change of border colour, say, blue to yellow.
1 ; Generally most approaches try to maintain main entry points as they are
1 ; GEOMETRIC PROOF.
1 ; Function to calculate the natural logarithm (to the base e ).
1 ; From keyboard and s-inkey$
1 ; From $00 Flash 0 to $FF COPY. The routine above has decoded all these.
1 ; Fp* form a subgroup of (Fp*)^2 of index 2, and so cannot be generators.
1 ; For this reason the accurate offsets calculated above are added to the
1 ; For other assemblers you may have to add directives like these near the
1 ; For control characters in the range 6 - 23d the following table
1 ; For both arcs and circles, constants derived from the central angle are
1 ; For ZX printer backspace up to first column but not beyond.
1 ; For 'x=y' NOT is applied to the subtraction result yielding true if the
1 ; For 'x<y' the same logic is used but the two values are first swapped on the
1 ; First the header data is saved. Then after a wait of 1 second
1 ; First test that the argument to LN is a positive, non-zero number.
1 ; First calculate the relative x coordinate to the end-point.
1 ; Finally draw the last straight line.
1 ; Fetch the moving ax and ay to the calculator stack.
1 ; FORTH-like language.
1 ; FORMULA' used in the arc loop will take care of all other points, but we
1 ; Error A unless the argument is between -1 and +1 inclusive.
1 ; Error A if the argument is 0 or negative.
1 ; Enter with: DE = #cycles - 1
1 ; End of true unary.
1 ; ERROR 6 if argument is more than about 88.
1 ; During the save loop a parity byte is maintained in H.
1 ; Division is accomplished by subtracting the two logs.
1 ; Dividing the sine of the step angle by the sine of the total angle gives
1 ; Destructively test if last value on calculator stack is less than zero.
1 ; Derived from arctan function above.
1 ; DE=character source
1 ; Credit April 1983, Dilwyn Jones. "Delving Deeper into your ZX Spectrum".
1 ; Continue when the circle's radius measures greater than one by forming
1 ; Continue when the arc will have a discernable shape.
1 ; Consider arithmetic modulo a prime p. There are p residue classes, and the
1 ; Compare with OR routine above.
1 ; Close but no cigar.
1 ; Chapter 5. Exercise 6. (For mathematicians only.)
1 ; Change the exponent of pi/2 from $81 to $83 giving 2*PI the central angle.
1 ; Carry is set if saved bit is 1. zero is reset NZ on entry.
1 ; Called from the interrupt 50 times a second.
1 ; By creating an isosceles triangle with two equal sides of 1, angles c and
1 ; Brennan calls numerous routines in this ROM.
1 ; Both this routine and the called KEYBOARD subroutine use the IY register
1 ; Both the CIRCLE algorithm and the ARC drawing algorithm make use of the
1 ; Both TEMP-PTR1 and TEMP-PTR2 are used by the READ command routine.
1 ; Bit 7 of second byte will be set if so.
1 ; Begin by calculating the number of chords which will be returned in B.
1 ; Backspace and up a line if that action is from the left of screen.
1 ; BEEP dur, pitch
1 ; BC=line/column
1 ; At this point we have either a type mismatch, a wildcard match or ten
1 ; At the opposite end, CIRCLE 128,88,1.23 will draw a circle as a perfect 3x3
1 ; At switch on, the Z80 chip is in Interrupt Mode 0.
1 ; Aside: 3E - 3F are therefore unused calculator literals.
1 ; As with all commands the address STMT-RET is on the stack.
1 ; As the calculator stack is quite busy, only the active parts are shown in
1 ; As the BASIC commands and expressions are interpreted, this routine is
1 ; As an alternative, the ASCII equivalent, upper or lower case,
1 ; Arrangement of two headers in workspace.
1 ; Any temporary memory areas used by the stream would be reclaimed and
1 ; Any attempt to CLOSE streams $00 to $04, without first opening the stream,
1 ; An important step after the evaluation of an expression is to test for
1 ; An edge is a transition from one mic state to another.
1 ; An arc can be drawn.
1 ; Although the three pairs of x/y values are the same for a circle, they
1 ; Although the test value has been deleted it is still above the calculator
1 ; Although the 'tab' and 'at' characters will not appear in a BASIC line,
1 ; Also see notes at Address Labels 0609 and 1CA5 if your assembler has
1 ; Also $60, '`', not used in BASIC but used in other languages, has been
1 ; All five bytes will be zero but first four only need be tested.
1 ; All Spectrum circles consist of two vertical lines at each side and two
1 ; After all for a circle, the radius is used. Consequently, a circle of
1 ; ASCII DEL, $7F, has been made a copyright symbol.
1 ; AC = 2 * sin(a/2) and so combining these we get
1 ; A value higher than 1 gives the required error as attempting to find the
1 ; A sync pulse is much shorter than the steady pulses of the lead-in.
1 ; A single entry point is used to evaluate six numeric and six string
1 ; A single call to 'sin' involves 63 memory checks and so values of sine
1 ; A rule of thumb is employed that uses a value z which for a circle is the
1 ; A return is made if the value represents a character that has
1 ; A possible repeat has been identified. HL addresses the raw key.
1 ; A continuation of the code at 0008.
1 ; A branch from the main SAVE-ETC routine at SAVE-ALL.
1 ; A bit consists of a period with mic on and blue border followed by
1 ; A BASIC line or variable is inserted at the current point. If the line
1 ; <font color=#9900FF>Note.</font> this isn't checked, but is subsequently handled by the system.
1 ; <font color=#9900FF>Note.</font> this first vertical chord is drawn at the radius so circles are
1 ; <font color=#9900FF>Note.</font> this entry point is used when out of memory at REPORT-4.
1 ; <font color=#9900FF>Note.</font> this entry point is a disabled Warm Restart that was almost certainly
1 ; <font color=#9900FF>Note.</font> the jump to DRW-STEPS is just to decrement B and jump into the
1 ; <font color=#9900FF>Note.</font> the golden rule that there are no restriction on anything is broken.
1 ; <font color=#9900FF>Note.</font> the curious double check on the range. With 26 UDGs the first check
1 ; <font color=#9900FF>Note.</font> the calculator stack actually holds tx, ty, ax, ay
1 ; <font color=#9900FF>Note.</font> that this is a very clever twist on what is after all a very clever,
1 ; <font color=#9900FF>Note.</font> that since the value at the top of the stack has arisen as a result
1 ; <font color=#9900FF>Note.</font> that any values stored in location 23681 will be overwritten with
1 ; <font color=#9900FF>Note.</font> that STACK-BC re-initializes the IY register if a user-written
1 ; <font color=#9900FF>Note.</font> that PR-CC-hi (23681) is used by this routine and if, in accordance
1 ; <font color=#9900FF>Note.</font> since the DJNZ instruction does not affect flags, the zero flag is
1 ; <font color=#9900FF>Note.</font> should selectively drop return address if code > 'U' ($55).
1 ; <font color=#9900FF>Note.</font> mem-0, mem-1 and mem-2 can be used again now...
1 ; <font color=#9900FF>Note.</font> for both the CIRCLE and ARC commands the minimum initial line count
1 ; <font color=#9900FF>Note.</font> although white-space is usually placed in a program to indent loops
1 ; <font color=#9900FF>Note.</font> after second sin, mem-0 and mem-1 become free.
1 ; <font color=#9900FF>Note.</font> a couple of LD (COORDS),A instructions would have been quicker, and
1 ; <font color=#9900FF>Note.</font> When inputting from the keyboard all characters are returned with
1 ; <font color=#9900FF>Note.</font> The string pointer is saved but not used!!
1 ; <font color=#9900FF>Note.</font> The location NMIADD was, in fact, later used by Sinclair Research
1 ; <font color=#9900FF>Note.</font> The high byte of the address D remains constant (which it should).
1 ; <font color=#9900FF>Note.</font> The Sinclair Interface 1 ROM written by Dr. Ian Logan and Martin
1 ; <font color=#9900FF>Note.</font> The Complete Spectrum ROM Disassembly incorrectly names DF-SZ as the
1 ; <font color=#9900FF>Note.</font> For ZASM use SUB $E0 as next instruction.
1 ; <font color=#9900FF>Note.</font> BC already contains $1821.
1 ; <font color=#9900FF>Note.</font> As a consequence of clearing the lower screen channel 0 is made
1 ; <font color=#9900FF>Note.</font> (Of course, 65537 is 2^16 + 1, not -1.)
1 ; <font color=#9900FF>Note.</font> 'sin' and 'cos' trash locations mem-0 to mem-2 so fetch mem-2 to the
1 ; 40-key Spectrum keyboard. The remaining key [SHIFT $27] is read directly.
1 ; 4) in workspace if accepting input but not that from INPUT LINE.
1 ; 3) in the edit buffer if parsing a direct command or a new BASIC line.
1 ; 251 straight lines for an arc between two points. In both cases the final
1 ; 2) in workspace if evaluating, for example, a string expression.
1 ; 2) from earlier with no carry to load or verify code.
1 ; 1) in the BASIC program area during line execution.
1 ; 1) From above to verify a program or array
1 ; --------------------
1 ; ------ ------ ---- ---- ---- ---- -----------------------------
1 ; -> for streams 4 - 15 then blank the entry.
1 ; - Thales, 640 - 546 B.C.
1 ; - Plato, 429 - 347 B.C.
1 ; - John Donne, Cambridge educated theologian, 1624
1 ; - Dr. Ian Logan, Understanding Your Spectrum, 1982.
1 ; - Albert Einstein, 1879-1955.
1 ; (same algorithm as the ZX Spectrum).
1 ; (s-inkey$ never gets into graphics mode.)
1 ; (excluding 1). By choosing a suitably, these can be made to look
1 ; (d) Tone duration in cycles = 5s/3.822ms = 1308 cycles
1 ; (b) Tone period in T-States = 3.822ms*fCPU = 13378
1 ; (a) Tone period = 1/261.624 = 3.822ms
1 ; (I referred to Pierre Samuel's "Algebraic Theory of Numbers".)
1 ; (HL has nothing important usually P_FLAG)
1 ; (75/65537) = -1. There is a multiplicative formula (ab/p) = (a/p)(b/p) (mod
1 ; ( from System Variable COORDS ) subtracted from them to give the relative
1 ; 'diameter' which is at the top of the calculator stack.
1 ; 'antiln'. e.g. PRINT EXP( LN 4 * 3 ) gives 64.
1 ; 'a number 53 bus' appear the same to the parser.
1 ; 'ROTATION FORMULA' (see later). It is only necessary to work out where
1 ; 'Natural' logarithms are powers to the base 'e', which like 'pi' is a
1 ; & yielding the result (b_(i+1)-1)/(p-1). RAND n (with 1<=n<=65535)
1 ; $03 - MERGE
1 ; $02 - VERIFY
1 ; $01 - LOAD
1 ; $00 - SAVE
1 ; #target rom ; declare target file format as binary.
1 ; #code 0,$4000 ; declare code segment.
1 ; "Spectrum Hardware Manual" causes a reset. The logic was obviously
1 ; "Nothing doth more molest and hinder calculators than the multiplications,
1 ; "Music is the hidden mathematical endeavour of a soul unconscious it
1 ; "I will be sufficiently rewarded if when telling it to others, you will
1 ; "However the programmer has failed to store the new print position
1 ; "He who can properly define and divide is to be considered a god"
1 ; "He said go forth and something about mathematics, I wasn't really
1 ; "Goe not Thou about to Square eyther circle" -
1 ; "Everything should be made as simple as possible, but not simpler"
1 ; | data | | Work Space | Stack | | Stack | Stack | | | |
1 ; | INPUT |NL| Temporary | Calc. | Spare | Machine | GOSUB |?|$3E| UDGs |
1 ; | Channel |$80| BASIC | Variables |$80| Edit Line |NL|$80|
1 ; | Info | | Program | Area | | or Command | | |
1 ; sides is equal to the square of the longest side opposite the right-angle.
1 ; rotation in radians (A).
1 ; on the next address pages this ROM out and the shadow ROM in.
1 ; of an unknown side when the length of one other side and an angle is
1 ; now make a multiple of 4 e.g. 29 becomes 28
1 ; not claim the discovery as your own, but will say it is mine."
1 ; listening" - overheard conversation between two unicorns.
1 ; length of the third side.
1 ; known.
1 ; is calculating" - Gottfried Wilhelm Liebnitz 1646 - 1716
1 ; divisions, square and cubical extractions of great numbers".
1 ; calculator stack and plot a point at the centre.
1 ; are despised
1 ; angle when the length of two of the sides is known.
1 ; ^ ^ ^ ^ ^
1 ; ^ ^ ^ ^ ^ ^ ^
1 ; [ The Odd Streak ].
1 ; Very useful if you know the length of two sides and wish to know the
1 ; Very helpful if you know two angles and wish to find the third.
1 ; This command clears the display.
1 ; There are three parameters e.g. DRAW 255, 175, .5
1 ; Then bring D to the top of the stack again.
1 ; The value is compressed into A register, no carry with valid circle.
1 ; The routine is also called during initialization and by the CLEAR command.
1 ; The first two are relative coordinates and the third is the angle of
1 ; The circle is no larger than a single pixel so delete the radius from the
1 ; Nobody is despised who can manage a crocodile AND Illogical persons
1 ; If it's difficult to write it should be difficult to read.
1 ; For an arc, a limit of 252 is imposed.
1 ; Bring back sin(A/2) from mem-0 which will shortly get trashed.
1 ; As an example for a circle of radius 87 the number of lines will be 29.
1 ; Adding 4 could set carry for arc, for the circle example, 28 becomes 32.
1 ; <font color=#9900FF>Note.</font> When the Sinclair Interface1 is fitted then an instruction fetch
1 ; (p/q)(q/p) = (-1)^{(p-1)(q-1)/4}
1 ; £ in most Spectrums.
1 ; © Find H and L for desired tone period:
1 ; The ZX81 uses p=65537 & a=75, & stores some b_i-1 in memory.
1 ; 65537 is a Mersenne prime 2^16-1. <font color=#9900FF>Note.</font>
1 ; 20 PRINT 1.72 * 6.89.
1 ; 10 PRINT EXP ( LN 1.72 + LN 6.89 )
1 ; 999999999 is printed as 1E+9
1 ; 100000009 is printed as 1.0000001E+8
1 ; 100000001 is printed as 1E+8
1 ; yRotated = y * cos(angle) - x * sin(angle)
1 ; xRotated = y * sin(angle) + x * cos(angle)
1 ; Yrotated = x * sin(a) + y * cos(a)
1 ; Xrotated = x * cos(a) - y * sin(a)
1 ; 00100111 00011000
1 ; -3 OR 2 returns 1.
1 ; -3 OR 0 returns -3.
1 ; | p | t | p | t | p | t | p | t |
1 ; | | | | | | | | | corresponding attribute is
1 ; | | | | | | | | |
1 ; {paper9 }{ ink9 }{ inv1 }{ over1} The print flags. Even bits are
1 ; {fl}{br}{ paper }{ ink } The temporary mask used for
1 ; {fl}{br}{ paper }{ ink } The temporary colour attributes
1 ; where fCPU = clock frequency of the CPU = 3.5MHz
1 ; wages - tax, TRUE, The meaning of life
1 ; pitch = # of semitones above/below middle C
1 ; HL = (Tp - 236) / 8 = (13378 - 236) / 8 = 1643 = 0x066B
1 ; DE = 1308 - 1 = 0x051B
1 ; 0 OR -3 returns 1.
1 ; 0 1 2 3 4 -Bits- 4 3 2 1 0
1 ; ___ ___ ___ ___ ___ ___ ___ ___ transparent colours. Any bit
1 ; ___ ___ ___ ___ ___ ___ ___ ___ temporary flags. The odd bits
1 ; ___ ___ ___ ___ ___ ___ ___ ___ system variable.
1 ; ___ ___ ___ ___ ___ ___ ___ ___
1 ; 7 6 5 4 3 2 1 0 what is already on the screen.
1 ; 10000001 00000000 00000000 00000000 00000000
1 ; -3 AND 0 returns 0.
1 ; = -1
1 ; = (2/3) (because 65537 = 2 mod 3)
1 ; 0 and 0 returns 0.
1 ; 0 and -2 returns 0.
1 ; zero sign low high unused
1 ; duration next on calculator stack
1 ; II +1 I
1 ; HL = tone period as described next
1 ; = 236 + 2048*H + 8*L = 236 + 8*HL
1 ; 90 deg.
1 ; 270 deg.
1 ; (pi/2)
1 ; spk mic { border }
1 ; |
1 ; coarse medium fine
1 ; (b_i-1)/(p-1)
1 ; ---5--> <---2--- <--3---
1 ; ; these only occur in unimplemented commands
1 ; ; similar commands. Clever.
1 ; ; from SAVE-ETC
1 ; ; embedded colour items.
1 ; ; although the routine expt-exp is called
1 ; and "hats" if h$ = "hatstand".
1 ; A
1 ; %011 will be xor/or result
1 ; comp -> C/F
1 ; ==== ===
1 ;
1 ;
1 ;
1 ;
1 ;
1 #end ; generic cross-assembler directive
1 #define equ .EQU
1 #define ORG .ORG
1 #define EQU .EQU
1 #define DEFW .WORD
1 #define DEFM .TEXT
1 #define DEFB .BYTE
1 XOR L ; include the new byte.
1 XOR L ; exclusive or with new byte.
1 XOR L ; compare with that on tape
1 XOR L ; compare type in A with first byte in L.
1 XOR L ;
1 XOR E ; apply masks
1 XOR E ; A contains zero, E contains one if the
1 XOR E ;
1 XOR D ; xor the two sets of flags
1 XOR C ; xor with inverse mask
1 XOR C ; xor sign 00000000 or 11111111
1 XOR C ; xor sign 00000000 11111111
1 XOR C ; two's complement
1 XOR C ; now with INVERSE MASK
1 XOR C ; compare with initial long-term state.
1 XOR B ; the y value
1 XOR B ; switch the pixel
1 XOR B ; restore unmasked bits xxyyyxxx
1 XOR B ; 010xxbbb
1 XOR B ;
1 XOR A ; signal a header.
1 XOR A ; set statement to zero.
1 XOR A ; set A to zero.
1 XOR A ; reset zero flag
1 XOR A ; default to array/slice - to be retained.
1 XOR A ; clear to signal small integer
1 XOR A ; clear to address table directly
1 XOR A ; clear to address message directly
1 XOR A ; clear to accept
1 XOR A ; clear carry flag.
1 XOR A ; clear carry flag (ready to rotate in).
1 XOR A ; clear accumulator.
1 XOR A ; clear accumulator to use as a running flag.
1 XOR A ; clear accumulator so that we can address
1 XOR A ; clear accumulator
1 XOR A ; Signal coming from START.
1 XOR (IY+$01) ; xor with FLAGS now updated by SCANNING.
1 XOR (IY+$01) ; xor with FLAGS - bit 6 should be same
1 XOR (IY+$01) ; xor with FLAGS
1 XOR (IY+$01) ; compare with bits of FLAGS
1 XOR (HL) ; xor with corresponding character byte
1 XOR (HL) ; will give $00 or $FF (inverse)
1 XOR (HL) ; toggle BIT 3 of FLAGS2 the capslock bit
1 XOR (HL) ; pick up the first or xor with first.
1 XOR (HL) ; permanent now as original
1 XOR (HL) ; only permanent bits affected
1 XOR (HL) ; on system variable.
1 XOR (HL) ; now XOR with source
1 XOR (HL) ; combine with HL
1 XOR (HL) ; bit 7 of HL will be set if number is negative.
1 XOR (HL) ; apply variable type indicator mask (above).
1 XOR (HL) ;
1 XOR $58 ; combine with base address.
1 XOR $40 ; xor with 01000000 (high byte screen start)
1 XOR $38 ;
1 XOR $10 ;(7) ; toggle output beep bit
1 XOR $0F ; toggle bits becomes range $88-$8F
1 XOR $0F ; switch from RED (mic on) to CYAN (mic off).
1 XOR $07 ; make the ink white.
1 XOR $07 ;
1 XOR $04 ; toggle the quotes flag.
1 XOR $03 ; and make blue/yellow.
1 SUB L ;
1 SUB D ; to give the statement after the NEXT
1 SUB D ; compare with old
1 SUB D ;
1 SUB C ; to range $00 - $20
1 SUB C ; subtract C to give count of trailing
1 SUB C ; sub sign 00000000 or 11111111
1 SUB C ; reverse the column number.
1 SUB B ; to range $00 - $17.
1 SUB B ; the new line number.
1 SUB B ; the
1 SUB B ; subtract the y value.
1 SUB B ; subtract the counter
1 SUB B ; subtract line number to reverse
1 SUB B ; subtract indicator byte setting carry
1 SUB (IY+$50) ; subtract new in SPOSNL_lo
1 SUB (IY+$4F) ; value of S_POSN_hi.
1 SUB (IY+$4F) ; subtract S_POSN_hi ithe current line number.
1 SUB (HL) ; subtract with that of 2nd string.
1 SUB (HL) ;
1 SUB $CE ; subtract 'DEF FN' - first command
1 SUB $AF ; subtract token 'CODE' value to reduce
1 SUB $90 ; make UDGs range 0-20d
1 SUB $80 ;
1 SUB $7E ; subtract
1 SUB $41 ; and return with carry set
1 SUB $31 ; '1'
1 SUB $30 ; convert from ASCII to digit
1 SUB $24 ; subtract '$' from fetched character
1 SUB $24 ; subtract '$'
1 SUB $20 ; reduce to ink range $10-$17
1 SUB $19 ;
1 SUB $18 ; and adjust.
1 SUB $17 ; decimal 23 ('tab')
1 SUB $10 ; reduce exponent by 2^16
1 SUB $10 ; for ASCII most will now be correct
1 SUB $0D ; subtract 13d leaving 1 and 2
1 SUB $0C ; 12 semitones = one octave
1 SUB $09 ; subtract 9 - max possible
1 SUB $08 ; subtract eight - which is not useful.
1 SUB $07 ;
1 SUB $06 ; subtract six from length_lo.
1 SUB $02 ; reduce range $FF-$02
1 SRL L ; L = medium part of tone period
1 SRL L ;
1 SRL H ; shift key bits right into carry.
1 SRA L ;
1 SET 7,L ; make attribute FLASH.
1 SET 7,C ; this converts a simple string to a
1 SET 7,C ; set numeric (Boolean) result for all others
1 SET 7,A ; use spare bit to signal checking syntax.
1 SET 7,(IY+$37) ; update FLAGX - signal handling INPUT LINE
1 SET 7,(IY+$01) ; update FLAGS - signal running program.
1 SET 7,(IY+$01) ; update FLAGS - Signal running program
1 SET 7,(IY+$01) ; update FLAGS - signal running program.
1 SET 7,(HL) ; set it to implied state
1 SET 7,(HL) ; set bit 7 at location
1 SET 7,(HL) ; now set to give true 32-bit mantissa
1 SET 7,(HL) ; invert it.
1 SET 6,C ; set numeric operand bit
1 SET 6,C ; set 6 signaling string if solitary 010
1 SET 6,(HL) ; signal numeric result
1 SET 6,(HL) ; set default to numeric result in FLAGS
1 SET 5,C ; signal numeric 011
1 SET 5,B ; signal not an array
1 SET 5,(IY+$02) ; update TV_FLAG - signal lower screen
1 SET 5,(IY+$02) ; update TV_FLAG - signal lower screen will
1 SET 5,(IY+$02) ; set TV_FLAG - signal lower screen requires
1 SET 5,(IY+$02) ; TV_FLAG - Signal lower screen requires
1 SET 5,(IY+$01) ; update FLAGS - signal a new key.
1 SET 5,(HL) ; signal in Input Mode for editor.
1 SET 4,(IY+$30) ; update FLAGS2 - signal K channel in use
1 SET 3,(IY+$02) ; update TV_FLAG - signal reprint the edit
1 SET 3,(HL) ; signal 'L' mode.
1 SET 3,(HL) ; signal 'L' mode to interrupt routine.
1 SET 2,(HL) ; signal 'L' mode. (used for input)
1 SET 1,(IY+$37) ; FLAGX - Signal a new variable
1 SET 1,(IY+$30) ; update FLAGS2 - signal printer buffer has
1 SET 1,(IY+$01) ; update FLAGS - signal printer in use.
1 SET 0,(IY+$30) ; update FLAGS2 - signal will be necessary to
1 SET 0,(IY+$02) ; update TV_FLAG - signal lower screen in use
1 SET 0,(IY+$02) ; signal to TV_FLAG - lower screen in use.
1 SET 0,(IY+$01) ; update FLAGS - signal suppress leading space.
1 SET 0,(HL) ; signal no leading space to FLAGS
1 SET 0,(HL) ; TV_FLAG - signal lower screen in use.
1 SCF ; set the carry flag.
1 SCF ; set carry flag to signal printer.
1 SCF ; set carry flag to show overflow
1 SCF ; set carry flag to load data on tape.
1 SCF ; set carry flag to control SET-DE
1 SCF ; set carry flag to calculate from end of
1 SCF ; set carry flag signalling looping exhausted.
1 SCF ; set carry flag signaling edge found within
1 SCF ; set carry flag ready to rotate in.
1 SCF ; set carry flag indicating load not verify.
1 SCF ; set carry flag indicating a variable not a
1 SCF ; set carry flag - not found
1 SCF ; prepare a set carry flag
1 SCF ; else set the carry flag.
1 SCF ; Set Carry Flag
1 SBC HL,SP ; if less than the machine stack pointer
1 SBC HL,DE ; test if an error address has been reached.
1 SBC HL,DE ; test against pointer address in DE and
1 SBC HL,DE ; subtract variable address
1 SBC HL,DE ; subtract to give total length.
1 SBC HL,DE ; subtract to give program length.
1 SBC HL,DE ; subtract to get length
1 SBC HL,DE ; subtract the two pointers.
1 SBC HL,DE ; subtract the two lengths.
1 SBC HL,DE ; subtract start point from end point.
1 SBC HL,DE ; subtract start from end to give length.
1 SBC HL,DE ; subtract position from old stkend
1 SBC HL,DE ; subtract high value from low to obtain
1 SBC HL,DE ; subtract and add back setting
1 SBC HL,DE ; subtract and
1 SBC HL,DE ; subtract address from start of line
1 SBC HL,DE ; new ramtop must be lower or the same.
1 SBC HL,DE ; if HL is greater than the value then jump
1 SBC HL,DE ; find length of BASIC and
1 SBC HL,BC ; subtract value from limit.
1 SBC HL,BC ; subtract old length from new.
1 SBC HL,BC ; subtract cursor address from pointer
1 SBC HL,BC ; point to start of value.
1 SBC HL,BC ; decrease HL by 5 to point to start.
1 SBC HL,BC ; cancel the last addition
1 SBC HL,BC ; HL points to start of value.
1 SBC A,A ; will be FF, if more, else 00.
1 SBC A,A ; will be FF for INVERSE 1 else zero
1 SBC A,A ; will be $FF if backward or $00 if forward.
1 SBC A,A ; result is $FF if so else $00.
1 SBC A,A ; restore a negative result sign
1 SBC A,A ; now form $FF bit 6 = numeric result
1 SBC A,A ; now $FF if negative or $00
1 SBC A,A ; byte will be $FF if negative, $00 if positive.
1 SBC A,A ; A = 0/FF if B is pos/neg
1 SBC A,A ; $FF if was 9, $00 if 0-8
1 SBC A,A ; $00 if 0-7, $FF if 8
1 SBC A,A ;
1 SBC A,$00 ; will set to $FF if carry set.
1 RST 30H ; using BC-SPACES restart.
1 RST 30H ; BC-SPACES makes DE point to start
1 RST 30H ; BC-SPACES in workspace.
1 RST 30H ; BC-SPACES creates the space sliding
1 RST 30H ; BC-SPACES creates the space in workspace.
1 RST 30H ; BC-SPACES creates the space for true
1 RST 30H ; BC-SPACES creates space for one character
1 RST 30H ; BC-SPACES creates room.
1 RST 30H ; BC-SPACES creates room in workspace.
1 RST 30H ; BC-SPACES
1 RST 28H ;; FP-CALC ;x or 0,d. first pass.
1 RST 28H ;; FP-CALC score>100 (1=TRUE 0=FALSE)
1 RST 28H ;; FP-CALC ; v, d.
1 RST 28H ;; FP-CALC add step and re-store
1 RST 28H ;; FP-CALC z, A.
1 RST 28H ;; FP-CALC y, x, last-x.
1 RST 28H ;; FP-CALC x, y.
1 RST 28H ;; FP-CALC x, y, sin(A/2), D.
1 RST 28H ;; FP-CALC x, y, r.
1 RST 28H ;; FP-CALC x, y, r, hc.
1 RST 28H ;; FP-CALC x, y, r, 2*PI.
1 RST 28H ;; FP-CALC x, y, A.
1 RST 28H ;; FP-CALC v,l.
1 RST 28H ;; FP-CALC ty, tx, coords_x.
1 RST 28H ;; FP-CALC tx, y, last-y.
1 RST 28H ;; FP-CALC rx, ty, coords_y
1 RST 28H ;; FP-CALC ax, ay.
1 RST 28H ;; FP-CALC ax, ay, Dx, ay, iy.
1 RST 28H ;; FP-CALC ax, ax, ix.
1 RST 28H ;; FP-CALC l,s.
1 RST 28H ;; FP-CALC x.
1 RST 28H ;; FP-CALC ;s.
1 RST 20H ; else NEXT-CHAR
1 RST 20H ; NEXT-CHAR to advance pointer
1 RST 20H ; NEXT-CHAR to address next character
1 RST 20H ; NEXT-CHAR skips any noise and white-space
1 RST 20H ; NEXT-CHAR re-initializes HL from CH_ADD
1 RST 20H ; NEXT-CHAR re-initializes HL and advances
1 RST 20H ; NEXT-CHAR moves CH-ADD past the statement
1 RST 20H ; NEXT-CHAR in FN statement advances to next
1 RST 20H ; NEXT-CHAR in BASIC area points to an
1 RST 20H ; NEXT-CHAR if a comma was found
1 RST 20H ; NEXT-CHAR fetches character after NEXT
1 RST 20H ; NEXT-CHAR advances to next statement/CR
1 RST 20H ; NEXT-CHAR advances to character after ')'
1 RST 20H ; NEXT-CHAR advances to bracket
1 RST 20H ; NEXT-CHAR advances the parsed character address.
1 RST 20H ; NEXT-CHAR advances past '=' to expression
1 RST 20H ; NEXT-CHAR advances past ')' in define
1 RST 20H ; NEXT-CHAR advance to next character
1 RST 20H ; NEXT-CHAR - variable must come next.
1 RST 20H ; NEXT-CHAR moves to next character
1 RST 18H ; GET-CHAR to fetch HL
1 RST 18H ; GET-CHAR puts character at CH_ADD in A
1 RST 18H ; GET-CHAR looks at the BASIC line
1 RST 18H ; GET-CHAR ignoring leading white-space.
1 RST 18H ; GET-CHAR gets next character in FN
1 RST 18H ; GET-CHAR gets character after variable name.
1 RST 18H ; GET-CHAR gets character addressed by CH_ADD.
1 RST 18H ; GET-CHAR from FN statement
1 RST 18H ; GET-CHAR fetches next character.
1 RST 18H ; GET-CHAR fetches adjusted character position
1 RST 18H ; GET-CHAR checks BASIC line
1 RST 18H ; GET-CHAR - HL points to place in statement.
1 RST 10H ; PRINT-A.
1 RST 10H ; PRINT-A prints using this alternate set.
1 RST 10H ; PRINT-A prints the carriage return (in A)
1 RST 10H ; PRINT-A prints '>' the current line cursor.
1 RST 10H ; PRINT-A outputs the control to current
1 RST 10H ; PRINT-A outputs parameter.
1 RST 10H ; PRINT-A outputs to current channel in
1 RST 08H ; ERROR-1
1 RST 28H ;; FP-CALC
1 RST 20H ; NEXT-CHAR
1 RRCA ; to the
1 RRCA ; to right.
1 RRCA ; thirty two (same as 5 RLCAs)
1 RRCA ; third and
1 RRCA ; the third RRCA - test for '<=', '>=' or '<>'.
1 RRCA ; test if quotes required.
1 RRCA ; shift
1 RRCA ; rotations to put set bit in
1 RRCA ; rotate permanent bits to temporary bits.
1 RRCA ; rotate bits
1 RRCA ; rotate bit 7 to bit 6
1 RRCA ; rotate bit 0 to bit 7
1 RRCA ; range 0-7.
1 RRCA ; now 32 - 256(0)
1 RRCA ; not five as we need offset * 2
1 RRCA ; multiply by
1 RRCA ; lose bit 0.
1 RRCA ; left.
1 RRCA ; for flash8/bright8 complete
1 RRCA ; elsewhere and is a candidate for
1 RRCA ; eight.
1 RRCA ; divide by
1 RRCA ; carry if bit 7 is set
1 RRCA ; by 32 (same as five RLCA instructions)
1 RRCA ; border colour bits moved to 2..0
1 RRCA ; bits 3 and 4
1 RRCA ; bits
1 RRCA ; bit 7 (flash) bit 6 (bright)
1 RRCA ; bit 0 to (C)
1 RRCA ; a subroutine.)
1 RRCA ; 4 places to right
1 RRCA ; 2nd RRCA causes eql/neql to set carry.
1 RRCA ; 00000xx0
1 RRCA ; (this code sequence is used twice
1 RRCA ; $09, $0A or $0B.
1 RRCA ; to match border bits on port #FE
1 RRCA ;
1 RRC C ; now rotate the sign byte $00 or $FF
1 RRA ; test outer key the space. (bit 6 moves to 5)
1 RRA ; test for space key pressed.
1 RRA ; rotate to bit 5.
1 RRA ; rotate it to carry flag again
1 RRA ; rotate bit 0 - SPACE
1 RRA ; rotate bit 0 - SHIFT
1 RRA ; restore zero to accumulator.
1 RRA ; if a space is pressed
1 RRA ; halve it 0, 1 or 2.
1 RRA ; bit 2 is INVERSE
1 RRA ; bit 0 to carry.
1 RRA ; bit 0 set if OVER 1
1 RRA ; and rotate back in altering sign
1 RRA ; 10xxxxxx
1 RRA ; 0xxxxxxx
1 RRA ; 010xxxxx
1 RR L ; rotate any carry into L
1 RR H ; rotate the sign bit to left of H
1 RR D ; and back to bit 7 of D restoring bit 1
1 RR B ; rotate bit 1/3 of original chr to carry
1 RLD ; shift RH nibble to left in (HL)
1 RLCA ; to bits 1 and 0 range $00 - $03.
1 RLCA ; to bit 2
1 RLCA ; to
1 RLCA ; the paper bits setting the
1 RLCA ; test bit 7 of original name.
1 RLCA ; shift the colour to
1 RLCA ; shift bits 0-2
1 RLCA ; shift bit 0
1 RLCA ; rotate to left
1 RLCA ; rotate to xyyyxxxx
1 RLCA ; rotate bit 7 of A to carry.
1 RLCA ; rotate
1 RLCA ; required position. yyyxxxxx
1 RLCA ; ink colour black.
1 RLCA ; double as there are two bytes per
1 RLCA ; bits 3-5
1 RLCA ; X4 - quadruple.
1 RLCA ; X2 - double.
1 RLCA ; 11100000 or 00011100
1 RLCA ; 01110000 or 00001110
1 RLC B ; form next port address e.g. FEFE > FDFE
1 RLC A ; double the value and set flags.
1 RLA ; test sign bit of A.
1 RLA ; test if the terminal inverted character.
1 RLA ; sets carry for abs and if number negative
1 RLA ; if backward jump, carry is set.
1 RLA ; destructively test
1 RLA ; carry to bit 0 of A
1 RL L ; rotate the carry bit into L.
1 RL E ; rotate leftmost print bit to carry
1 RL E ; pick up carry in E if line before current
1 RL E ; C<xxxxxxxx<C
1 RL C ; shift AC left into carry
1 RL B ; rotate the B register left
1 RL B ;
1 RL (HL) ; rotate the sign bit into the carry flag.
1 RL (HL) ;
1 RETN ; return to previous interrupt state.
1 RET Z ; shift key pressed.
1 RET Z ; return with failure when $FF passed.
1 RET Z ; return with carry reset if so.
1 RET Z ; return now if in editing mode
1 RET Z ; return if zero. >>
1 RET Z ; return if zero.
1 RET Z ; return if zero (strings only).
1 RET Z ; return if zero
1 RET Z ; return if the screen is full and the line
1 RET Z ; return if string result.
1 RET Z ; return if so to ED-LOOP
1 RET Z ; return if so as complete. >>>>>
1 RET Z ; return if so - e.g. INPUT (p$); a$
1 RET Z ; return if so -->
1 RET Z ; return if result zero
1 RET Z ; return if positive.
1 RET Z ; return if positive number.
1 RET Z ; return if one key or no key.
1 RET Z ; return if not. >>
1 RET Z ; return if checking syntax
1 RET Z ; return if FP-TO-BC indicated positive.
1 RET Z ; return also with carry clear if so.
1 RET Z ; return also - e.g. PRINT a
1 RET Z ; return also
1 RET Z ; or continue and print carriage return in
1 RET Z ; if duration = 0, skip BEEP and avoid 65536 cycle
1 RET Z ; and return if not pressed.
1 RET Z ; Return if upper screen in use.
1 RET P ;
1 RET NZ ; return with solitary symbol shift
1 RET NZ ; return with carry set if at end
1 RET NZ ; return immediately in runtime
1 RET NZ ; return immediately if so.
1 RET NZ ; return if yet to match (carry will be set).
1 RET NZ ; return if so.
1 RET NZ ; return if so with main code.
1 RET NZ ; return if so
1 RET NZ ; return if shift pressed.
1 RET NZ ; return if result is numeric.
1 RET NZ ; return if not zero.
1 RET NZ ; return if not zero as already in full
1 RET NZ ; return if not zero and with carry reset.
1 RET NZ ; return if not yet zero.
1 RET NZ ; return if not in editor - to ED-LOOP.
1 RET NZ ; return if not at exact position.
1 RET NZ ; return if no match.
1 RET NZ ; return if no match e.g. CODE vs. DATA.
1 RET NZ ; return if no match >>>
1 RET NZ ; return if more as must be
1 RET NZ ; return if invalid combinations
1 RET NZ ; return as no exponent.
1 RET NZ ; return (via CL-SET) if greater
1 RET NZ ; if we have collected 2 keys already
1 RET NC ; return with just a shift (in B now)
1 RET NC ; return with carry clear if so.
1 RET NC ; return to SA/LD-RET. - - >
1 RET NC ; return if space pressed. >>>
1 RET NC ; return if space pressed or time-out.
1 RET NC ; return if so.
1 RET NC ; return if so
1 RET NC ; return if second non-zero, first is result.
1 RET NC ; return if scrolling unnecessary
1 RET NC ; return if number was not zero - the string
1 RET NC ; return if match was found. ->
1 RET NC ; return if line has been passed or matched.
1 RET NC ; return if just a single shift
1 RET NC ; return if altered.
1 RET NC ; return early if checking syntax.
1 RET NC ; make an early return if so >>>
1 RET NC ; iteration. Return to STMT-RET if a loop is
1 RET NC ; items - return if success.
1 RET NC ; but if the letter wasn't found in the
1 RET NC ; Return if it is significant.
1 RET NC ;
1 RET M ; return if the null string.
1 RET M ; return if not - but continue with parent
1 RET M ; return if $FF, as leading spaces not
1 RET C ; will return when character is not numeric >
1 RET C ; then return - OK.
1 RET C ; return, if so, with carry set.
1 RET C ; return with space, enter and symbol-shift
1 RET C ; return with carry set if so.
1 RET C ; return with carry set if > 65535, overflow
1 RET C ; return with carry set "key found" for
1 RET C ; return with acceptable keys.
1 RET C ; return to ED-LOOP if already at left
1 RET C ; return if was zero as this
1 RET C ; return if successful.
1 RET C ; return if so leaving zero unchanged.
1 RET C ; return if result was zero - first operand,
1 RET C ; return if nothing more to output. ->
1 RET C ; return if not reset
1 RET C ; return if not numeric character
1 RET C ; return if no more iterations possible.
1 RET C ; return if less.
1 RET C ; return if less than zero character.
1 RET C ; return if greater than 'OVER', $DE.
1 RET C ; return if carry set ( entry = set-de)
1 RET C ; return carry set if zero
1 RET C ; is within first range
1 RET C ; for all messages and function tokens
1 RET C ; exit if so as no change is required.
1 RET C ; Return if so as no trailing space required.
1 RET C ; Return if numeric else continue into
1 RET C ; Return if no trailing space.
1 RET Z ; return to previous call in chain if checking
1 RET ; zero set if exact match.
1 RET ; to give 0 and 1 flash codes.
1 RET ; to STMT-RET (or GO-SUB command)
1 RET ; the USR function returns value of BC.
1 RET ; return. with zero set if two together.
1 RET ; return. ->
1 RET ; return. with Q1 and Q4 >>>
1 RET ; return. ->
1 RET ; return.
1 RET ; return without updating column position
1 RET ; return with zero set if keyboard is use.
1 RET ; return with result.
1 RET ; return with new area ready to be populated.
1 RET ; return with carry set.
1 RET ; return with carry set if zero.
1 RET ; return with carry set
1 RET ; return with carry reset if successful
1 RET ; return with carry reset
1 RET ; return with HL pointing at the numeric
1 RET ; return with H'L' pointing to location
1 RET ; return with DE unchanged
1 RET ; return with DE addressing new STKEND
1 RET ; return with CHANS displacement in BC
1 RET ; return with BC set at 5.
1 RET ; return with A holding $0D
1 RET ; return with + int x on stack.
1 RET ; return via CL-SET for lower display.
1 RET ; return via CL-SET (was pushed on stack).
1 RET ; return values are the length of area in BC,
1 RET ; return to update STRMS entry thereby
1 RET ; return to the calling routine.
1 RET ; return to interrupt routine.
1 RET ; return to calling routine COPY/COPY-BUFF.
1 RET ; return to STMT-RET to branch to new
1 RET ; return to STMT-RET (or RUN)
1 RET ; return to STMT-RET
1 RET ; return to ED-LOOP
1 RET ; return signalling success.
1 RET ; return pointing to a valid character.
1 RET ; return ignoring pushed value, CL-SET
1 RET ; return from here.
1 RET ; return from here in runtime to STMT-RET.
1 RET ; return and continue into PO-STORE
1 RET ; return ->
1 RET ; return - zero flag will be set if so.
1 RET ; return - item finished >>>
1 RET ; return - either a simple return
1 RET ; return - - >
1 RET ; return (with zero set if it was).
1 RET ; return (B has other key still)
1 RET ; make the return.
1 RET ; make an indirect jump to the routine
1 RET ; in STRMS and return.
1 RET ; if it is less that 'A'
1 RET ; for return value.
1 RET ; else return with 16-bit result in HL.
1 RET ; carry will be set if not pressed.
1 RET ; carry set if within a-z.
1 RET ; but return from here if checking syntax.
1 RET ; before returning
1 RET ; and return to loop or quit.
1 RET ; and return >>>
1 RET ; and return (entry = set-hl (in input))
1 RET ; and make an indirect jump to the command.
1 RET ; and make an indirect jump to routine
1 RET ; and make an indirect jump to it.
1 RET ; Return - carry clear if character '0' - '9'
1 RET ; Return
1 RET ; RETURN to ED-LOOP.
1 RET ; Make an indirect jump forward to routine.
1 RES 7,H ; reset flash mask bit so active.
1 RES 7,C ; reset bit 7 of op code for 'str$', 'chr$'
1 RES 7,(IY+$37) ; update FLAGX - signal not INPUT LINE.
1 RES 7,(IY+$01) ; update FLAGS - signal checking syntax.
1 RES 7,(IY+$01) ; update FLAGS - signal checking syntax
1 RES 7,(HL) ; cancel the bit anyway.
1 RES 6,C ; signal string operand for 'code', 'val' and
1 RES 6,C ; signal 'numeric' array even if string as
1 RES 6,C ; make long named type 001
1 RES 6,(IY+$57) ; reset P_FLAG - signal NOT PAPER 9 ?
1 RES 6,(IY+$01) ; update FLAGS - signal string result.
1 RES 6,(IY+$01) ; update FLAGS - signal string result for
1 RES 6,(IY+$01) ; update FLAGS - Signal string result
1 RES 6,(IY+$01) ; set FLAGS - Signal string result
1 RES 6,(HL) ; signal string result
1 RES 6,(HL) ; reset bit 6 of FLAGS to show string result.
1 RES 5,B ; signal a string variable.
1 RES 5,(IY+$37) ; update FLAGX - signal in EDIT not INPUT mode.
1 RES 5,(IY+$02) ; update TV_FLAG - signal don't clear lower
1 RES 5,(IY+$01) ; update bit 5 of FLAGS - signal no new key.
1 RES 5,(IY+$01) ; update FLAGS - reset the new key flag.
1 RES 5,(IY+$01) ; update FLAGS - signal no new key
1 RES 5,(HL) ; signal not in input mode
1 RES 5,(HL) ; signal 'no new key'.
1 RES 5,(HL) ; TV_FLAG - signal do not clear lower screen.
1 RES 4,(IY+$30) ; update FLAGS2 - signal K channel not in use.
1 RES 4,(IY+$02) ; update TV_FLAG - signal no auto listing.
1 RES 4,(IY+$02) ; reset TV_FLAG - signal auto listing finished.
1 RES 3,(IY+$02) ; update TV_FLAG - signal no change in mode
1 RES 3,(IY+$01) ; update FLAGS - signal use 'K' mode for
1 RES 3,(HL) ; signal 'K' mode initially.
1 RES 2,(IY+$30) ; update FLAGS2 - signal NOT in QUOTES.
1 RES 2,(IY+$01) ; initialize FLAGS to 'K' mode and leave
1 RES 2,(HL) ; signal 'K' mode. (starts before keyword)
1 RES 1,(IY+$30) ; set FLAGS2 - signal printer buffer is clear.
1 RES 0,(IY+$30) ; update FLAGS2 - signal main screen is clear.
1 RES 0,(IY+$07) ; set MODE to 'L'
1 RES 0,(IY+$02) ; update TV_FLAG - signal main screen in use.
1 RES 0,(IY+$02) ; update TV_FLAG - signal main screen in use
1 RES 0,(IY+$02) ; signal to TV_FLAG - main screen in use.
1 RES 0,(IY+$01) ; update FLAGS - signal leading space required.
1 RES 0,(HL) ; allow for leading space
1 PUSH IX ; transfer IX,
1 PUSH IX ; save pointer to descriptor.
1 PUSH HL ; transfer address
1 PUSH HL ; the IY register unfortunately.
1 PUSH HL ; save workspace area pointer.
1 PUSH HL ; save variables area pointer on stack.
1 PUSH HL ; save variable first character pointer
1 PUSH HL ; save total space
1 PUSH HL ; save the supplied limit.
1 PUSH HL ; save the pointer to next literal on stack
1 PUSH HL ; save the pointer on stack.
1 PUSH HL ; save the pointer address.
1 PUSH HL ; save the holding register.
1 PUSH HL ; save the dimension counter
1 PUSH HL ; save system variable hi pointer.
1 PUSH HL ; save state map location
1 PUSH HL ; save start of quoted text.
1 PUSH HL ; save start address in DEF FN ***
1 PUSH HL ; save position in DEF FN statement
1 PUSH HL ; save pointer.
1 PUSH HL ; save pointer to the last value/result.
1 PUSH HL ; save pointer to second character ^2
1 PUSH HL ; save pointer to offset byte
1 PUSH HL ; save pointer to next literal
1 PUSH HL ; save pointer to last char in vars
1 PUSH HL ; save pointer to first letter ^1
1 PUSH HL ; save pointer
1 PUSH HL ; save original length.
1 PUSH HL ; save masks.
1 PUSH HL ; save line address underneath
1 PUSH HL ; save it on stack.
1 PUSH HL ; save it
1 PUSH HL ; save destination
1 PUSH HL ; save data pointer.
1 PUSH HL ; save bitmap start
1 PUSH HL ; save address on stack and
1 PUSH HL ; save address of line.
1 PUSH HL ; save address in DEF FN statement
1 PUSH HL ; save HL - pointer to first operand.
1 PUSH HL ; save HL
1 PUSH HL ; registers
1 PUSH HL ; re-save return address.
1 PUSH HL ; put pos pointer on stack.
1 PUSH HL ; pushed onto the machine stack.
1 PUSH HL ; push the pointer.
1 PUSH HL ; push the error address.
1 PUSH HL ; push the address.
1 PUSH HL ; push the address on the stack.
1 PUSH HL ; push the address on machine stack.
1 PUSH HL ; push data pointer/rubbish.
1 PUSH HL ; push STKEND value.
1 PUSH HL ; pointer to whatever comes after
1 PUSH HL ; perhaps an obsolete entry point.
1 PUSH HL ; now restore the error address
1 PUSH HL ; is saved on stack to handle errors.
1 PUSH HL ; is saved on stack as terminating routine.
1 PUSH HL ; is pushed on stack and addressed by ERR_SP.
1 PUSH HL ; is pushed as the error routine
1 PUSH HL ; is pushed as common exit route.
1 PUSH HL ; is now pushed as a return address
1 PUSH HL ; else save workspace pointer.
1 PUSH HL ; and transfer it
1 PUSH HL ; and save the address
1 PUSH HL ; and save that too.
1 PUSH HL ; and save start on machine stack also.
1 PUSH HL ; and save on the machine stack.
1 PUSH HL ; and save on stack
1 PUSH HL ; and save also
1 PUSH HL ; and save again
1 PUSH HL ; and save
1 PUSH HL ; and pushed onto stack.
1 PUSH HL ; and push also
1 PUSH HL ; and initial address.
1 PUSH HL ; and destination
1 PUSH HL ; Save address of workspace.
1 PUSH HL ; * save start
1 PUSH DE ; transfer the start of new space to
1 PUSH DE ; saved code/parameters
1 PUSH DE ; save this pointer.
1 PUSH DE ; save the top line number.
1 PUSH DE ; save the start in workspace
1 PUSH DE ; save the address of the start of the string.
1 PUSH DE ; save the E flag.
1 PUSH DE ; save system variable address.
1 PUSH DE ; save start2 *.
1 PUSH DE ; save start of second string
1 PUSH DE ; save start of destination.
1 PUSH DE ; save start in workspace.
1 PUSH DE ; save start address.
1 PUSH DE ; save source address
1 PUSH DE ; save source
1 PUSH DE ; save screen start address
1 PUSH DE ; save pointer to the now obsolete number
1 PUSH DE ; save pointer to lowest number for result.
1 PUSH DE ; save pointer to first new location.
1 PUSH DE ; save pointer to STKEND.
1 PUSH DE ; save old line/column.
1 PUSH DE ; save new value
1 PUSH DE ; save new prog/vars pointer.
1 PUSH DE ; save it again
1 PUSH DE ; save dest pointer in prog/vars area.
1 PUSH DE ; save data space
1 PUSH DE ; save FN ')' pointer.
1 PUSH DE ; save D - result type
1 PUSH DE ; push the address STMT-RET.
1 PUSH DE ; preserve DE.
1 PUSH DE ; now address of routine
1 PUSH DE ; else save start address of string
1 PUSH DE ; and workspace pointer
1 PUSH DE ; and save.
1 PUSH DE ; and save it on the stack again.
1 PUSH DE ; and save it on the stack
1 PUSH DE ; and push for return address.
1 PUSH DE ; and normal STKEND
1 PUSH DE ; and STKEND.
1 PUSH DE ;
1 PUSH BC ; then the address of the machine code
1 PUSH BC ; save with the type.
1 PUSH BC ; save type in C.
1 PUSH BC ; save the line and column in BC.
1 PUSH BC ; save the letter/type
1 PUSH BC ; save the length.
1 PUSH BC ; save the length again.
1 PUSH BC ; save the current line number
1 PUSH BC ; save sign (in B)
1 PUSH BC ; save return address
1 PUSH BC ; save new length.
1 PUSH BC ; save length of string to be sliced.
1 PUSH BC ; save length
1 PUSH BC ; save it.
1 PUSH BC ; save dimensions/type
1 PUSH BC ; save dimension size ***
1 PUSH BC ; save current priority/operation
1 PUSH BC ; save current print position
1 PUSH BC ; save C the string test, and B the letter.
1 PUSH BC ; save BC - value 5 from test room ??.
1 PUSH BC ; save BC
1 PUSH BC ; resave return address - ED-LOOP.
1 PUSH BC ; put in on stack.
1 PUSH BC ; push the error address.
1 PUSH BC ; push the address
1 PUSH BC ; preserve BC which is used as a store.
1 PUSH BC ; preserve BC
1 PUSH BC ; now re-stack the address STMT-RET
1 PUSH BC ; is now pushed on stack as looping address.
1 PUSH BC ; and the line counter.
1 PUSH BC ; and the length.
1 PUSH BC ; and save it.
1 PUSH BC ; and save again.
1 PUSH BC ; and save again on stack.
1 PUSH BC ; and length.
1 PUSH BC ; and length (*)
1 PUSH BC ; and its length.
1 PUSH BC ; and PUSH onto GO SUB stack.
1 PUSH BC ; Save the line count on the machine stack.
1 PUSH BC ; Restore line counter to the machine stack.
1 PUSH BC ; Preserve the number of lines in B.
1 PUSH BC ; B = octave displacement from middle C, 2's complement: -5<=B<=10
1 PUSH BC ; ** save length of new program line/variable.
1 PUSH BC ; ** and length.
1 PUSH BC ; * save it.
1 PUSH BC ; BC = tone_period(HL)
1 PUSH AF ; save this mask on the stack
1 PUSH AF ; save the value and flags
1 PUSH AF ; save the token number to control
1 PUSH AF ; save the running flag.
1 PUSH AF ; save the input character.
1 PUSH AF ; save the colour token.
1 PUSH AF ; save the code
1 PUSH AF ; save the argument.
1 PUSH AF ; save shifted exponent.
1 PUSH AF ; save result sign.
1 PUSH AF ; save on stack to prevent lower screen
1 PUSH AF ; save key.
1 PUSH AF ; save it again.
1 PUSH AF ; save flag (will be $FF if parameter>limit)
1 PUSH AF ; save count.
1 PUSH AF ; save control.
1 PUSH AF ; save character.
1 PUSH AF ; save character and flags
1 PUSH AF ; save again
1 PUSH AF ; save A and carry
1 PUSH AF ; save A
1 PUSH AF ; re-save shifted exponent
1 PUSH AF ; preserve flags.
1 PUSH AF ; preserve accumulator though not corrupted.
1 PUSH AF ; and save on stack before any branching.
1 PUSH AF ; and save it on stack.
1 PUSH AF ; and preserve
1 PUSH AF ;
1 POP IX ; transfer to IX.
1 POP IX ; to IX register.
1 POP IX ; to IX register pair.
1 POP IX ; the available index register.
1 POP IX ; retrieve pointer to start
1 POP IX ; restore descriptor pointer.
1 POP IX ; restore IX.
1 POP IX ; * and start.
1 POP HL ; saved value not required.
1 POP HL ; restore xx
1 POP HL ; restore workspace pointer.
1 POP HL ; restore workspace pointer
1 POP HL ; restore variable position
1 POP HL ; restore topmost address.
1 POP HL ; restore the result pointer.
1 POP HL ; restore the limit.
1 POP HL ; restore the holding register.
1 POP HL ; restore the data pointer.
1 POP HL ; restore the address pointer.
1 POP HL ; restore the address of the next line.
1 POP HL ; restore the address of CURCHL.
1 POP HL ; restore the
1 POP HL ; restore temporary masks
1 POP HL ; restore system variable hi pointer.
1 POP HL ; restore start.
1 POP HL ; restore start of string to HL.
1 POP HL ; restore start of string in workspace.
1 POP HL ; restore start address.
1 POP HL ; restore saved character address in program.
1 POP HL ; restore saved HL register.
1 POP HL ; restore pointer to the first byte.
1 POP HL ; restore pointer to next literal.
1 POP HL ; restore pointer to first character of variable
1 POP HL ; restore pointer to 2nd character.
1 POP HL ; restore pointer
1 POP HL ; restore original screen/printer position
1 POP HL ; restore original result pointer
1 POP HL ; restore original P_FLAG.
1 POP HL ; restore original ATTR_T/MASK_T.
1 POP HL ; restore original ATTR_T, MASK_T
1 POP HL ; restore old program pointer.
1 POP HL ; restore next literal pointer.
1 POP HL ; restore next literal pointer from stack
1 POP HL ; restore new value
1 POP HL ; restore map pointer
1 POP HL ; restore length of second to HL.
1 POP HL ; restore first location in workspace to HL.
1 POP HL ; restore current channel.
1 POP HL ; restore current channel address
1 POP HL ; restore address.
1 POP HL ; restore HL.
1 POP HL ; restore DEF FN pointer
1 POP HL ; registers.
1 POP HL ; re-fetch start of quoted text.
1 POP HL ; re-fetch first length
1 POP HL ; pop the start address in DEF FN statement
1 POP HL ; pop the original DEFADD value
1 POP HL ; pop the limit length.
1 POP HL ; pop the length.
1 POP HL ; pop the data pointer.
1 POP HL ; pop the FN ')' pointer
1 POP HL ; pop result sign pointer
1 POP HL ; pop pointer to variable in assignment.
1 POP HL ; pop length to HL as default end point
1 POP HL ; pop dimension counter, array type
1 POP HL ; pop counter
1 POP HL ; pop P_FLAG to H.
1 POP HL ; original STKEND is now RESULT pointer.
1 POP HL ; now the error address.
1 POP HL ; fetch the error address.
1 POP HL ; else restore
1 POP HL ; drop the return address.
1 POP HL ; drop the looping address
1 POP HL ; drop the address of previous
1 POP HL ; drop return address.
1 POP HL ; drop original CH_ADD which points to
1 POP HL ; drop line address
1 POP HL ; drop address ED-ERROR
1 POP HL ; and start of string
1 POP HL ; and pop into HL.
1 POP HL ; and pointer to possible result.
1 POP HL ; and pointer to last value
1 POP HL ; and display address.
1 POP HL ; address the start.
1 POP HL ; address of start
1 POP HL ; HL = tone period
1 POP HL ; * restore the saved STRMS pointer.
1 POP DE ; the 2nd descriptor, to DE.
1 POP DE ; restore the ramtop value.
1 POP DE ; restore the prog/vars pointer
1 POP DE ; restore the old line column.
1 POP DE ; restore the E flag.
1 POP DE ; restore start of string in workspace.
1 POP DE ; restore source
1 POP DE ; restore screen address
1 POP DE ; restore real STKEND
1 POP DE ; restore previous address to DE.
1 POP DE ; restore pointer to first FN argument.
1 POP DE ; restore pointer - new STKEND.
1 POP DE ; restore old system variable address.
1 POP DE ; restore length to DE.
1 POP DE ; restore initial DE.
1 POP DE ; restore character source address
1 POP DE ; restore and
1 POP DE ; restore DE
1 POP DE ; registers.
1 POP DE ; registers and
1 POP DE ; pop the return address STMT-RET.
1 POP DE ; pop the flag to D.
1 POP DE ; pop the dimension pointer. ***
1 POP DE ; pop the address of the position.
1 POP DE ; pop pointer to new area.
1 POP DE ; pop pointer to 2nd. char
1 POP DE ; pop STKEND to DE.
1 POP DE ; pop STKEND
1 POP DE ; pointers.
1 POP DE ; now a possible BASIC return line.
1 POP DE ; fetch workspace 1st character pointer
1 POP DE ; fetch saved start of string to DE.
1 POP DE ; drop pointer to 1st prog char v1
1 POP DE ; discard pointer to 'DEF FN'.
1 POP DE ; and pop in into D'E'
1 POP DE ; and DE register.
1 POP DE ; STKEND
1 POP DE ; Restore the initial DE value.
1 POP DE ; DE = first operand
1 POP DE ; * re-fetch trailing space byte to D
1 POP DE ; * pop value for PROG which may have been
1 POP DE ; * pop the data length.
1 POP BC ; the start of data pointer is added
1 POP BC ; the source address CHARS or UDG
1 POP BC ; saved
1 POP BC ; retrieve length of line.
1 POP BC ; retrieve BASIC length
1 POP BC ; restore the saved
1 POP BC ; restore the result to balance stack.
1 POP BC ; restore the line counter.
1 POP BC ; restore the line $01-$24.
1 POP BC ; restore the length of string.
1 POP BC ; restore the flags
1 POP BC ; restore the chord count
1 POP BC ; restore sign
1 POP BC ; restore result.
1 POP BC ; restore original BC
1 POP BC ; restore old WORKSP
1 POP BC ; restore new length.
1 POP BC ; restore line/column
1 POP BC ; restore letter/type
1 POP BC ; restore length to BC
1 POP BC ; restore length from stack.
1 POP BC ; restore counts.
1 POP BC ; restore counter.
1 POP BC ; restore count for return value.
1 POP BC ; restore code/parameters
1 POP BC ; restore character in C
1 POP BC ; restore address.
1 POP BC ; restore BC.
1 POP BC ; restore BC
1 POP BC ; restore 5 counter to BC ??.
1 POP BC ; pop total space
1 POP BC ; pop the type.
1 POP BC ; pop the number of dimensions.
1 POP BC ; pop the Error Address.
1 POP BC ; pop dimension counter/type
1 POP BC ; pop dimension counter.
1 POP BC ; pointers
1 POP BC ; old value of SPOSN_L
1 POP BC ; length of first
1 POP BC ; fetch the saved registers.
1 POP BC ; fetch counts.
1 POP BC ; drop the return address and
1 POP BC ; drop return address if at end.
1 POP BC ; drop return address
1 POP BC ; drop address of calling routine.
1 POP BC ; drop address STMT-RET.
1 POP BC ; discard the
1 POP BC ; and line column
1 POP BC ; and fetch the letter
1 POP BC ; and character counter in B
1 POP BC ; Restore the straight line count.
1 POP BC ; Restore the line count to the B register.
1 POP BC ; Restore the arc counter from the machine stack.
1 POP BC ; Restore registers.
1 POP BC ; Balance the machine stack
1 POP BC ; Balance machine stack by taking chord-count.
1 POP BC ; ** pop length
1 POP AF ; retrieve the value
1 POP AF ; restore token and continue.
1 POP AF ; restore the value
1 POP AF ; restore the permanent flag.
1 POP AF ; restore the number.
1 POP AF ; restore the character code.
1 POP AF ; restore test against '$'.
1 POP AF ; restore scroll counter.
1 POP AF ; restore saved result type to A
1 POP AF ; restore previous flags
1 POP AF ; restore possible result sign.
1 POP AF ; restore original P_FLAG
1 POP AF ; restore message/token number
1 POP AF ; restore expected result flag (bit 6).
1 POP AF ; restore count
1 POP AF ; restore character and mask
1 POP AF ; restore carry (set if eql/neql)
1 POP AF ; restore A and carry.
1 POP AF ; restore A and carry flag from comparison.
1 POP AF ; restore A
1 POP AF ; registers.
1 POP AF ; pop the running flag.
1 POP AF ; pop the flag.
1 POP AF ; pop the exponent.
1 POP AF ; pop preserved accumulator.
1 POP AF ; pop carry and
1 POP AF ; pop A
1 POP AF ; pop A
1 POP AF ; get saved key value.
1 POP AF ; fetch first character back.
1 POP AF ; fetch back the letter name.
1 POP AF ; else restore flags.
1 POP AF ; else restore flag.
1 POP AF ; drop return address SCAN-LOOP
1 POP AF ; bring the code back
1 POP AF ; bring back the true error number
1 POP AF ; and restore character.
1 POP AF ; A = octave displacement from middle C, 2's complement: -5<=A<=10
1 POP DE ;
1 OUT (C),A ; perform the operation.
1 OUT ($FE),A ;(11) ; output pulse
1 OUT ($FE),A ; switch to mic on and red.
1 OUT ($FE),A ; send to port to effect the change of colour.
1 OUT ($FE),A ; outputting to port effects an immediate
1 OUT ($FE),A ; output to port.
1 OUT ($FE),A ; output mic off, cyan border.
1 OUT ($FE),A ; output byte $02/$0D to tape port.
1 OUT ($FE),A ; change the border colour.
1 OUT ($FE),A ; and set it now by writing to a port.
1 OUT ($FB),A ; to stop the slowed printer motor.
1 OUT ($FB),A ; slow the printer for the
1 OUT ($FB),A ; printer motor.
1 OUT ($FB),A ; and output to port.
1 OR L ; zero.
1 OR L ; is the null string and hold flags.
1 OR L ; indicating variable does not already exist.
1 OR L ; e.g. LOAD 'x' CODE
1 OR L ;
1 OR L ;
1 OR E ;(4) ; (low->low). if cycle countdown = 0
1 OR E ; zero if closed.
1 OR E ; test the low byte for zero
1 OR E ; test against low byte.
1 OR E ; low byte E to A and test for zero
1 OR E ; expected bytes.
1 OR E ; contain zero so test for this.
1 OR C ; zero.
1 OR C ; zero length.
1 OR C ; the null string.
1 OR C ; the line is non-zero.
1 OR C ; the length.
1 OR C ; test length of first string.
1 OR C ; result is zero.
1 OR C ; of the string.
1 OR C ; length is zero and sets flag accordingly.
1 OR C ; is zero and
1 OR C ; is one character.
1 OR C ; indicates the stream is closed.
1 OR C ; for zero length
1 OR C ; combine with stored pattern
1 OR C ; as arrays and strings begin at 1.
1 OR C ; and make a
1 OR C ; $FF for abs, no change neg
1 OR C ;
1 OR B ; result would be zero.
1 OR B ; or with mask to make white
1 OR (HL) ; sets bit 7 for abs
1 OR (HL) ; set bit 0 if simple variable to be reclaimed
1 OR (HL) ; combine with first byte of first
1 OR (HL) ; OR with third byte.
1 OR (HL) ; OR with second byte and clear carry.
1 OR (HL) ; OR with fourth byte.
1 OR $F8 ; or with 11111000 paper/bright/flash 8
1 OR $9F ; combine with 10011111.
1 OR $80 ; now set bit 7 as last character of long
1 OR $80 ; invert the last character.
1 OR $60 ; or with 01100000 presume a simple variable.
1 OR $58 ; form correct high byte for third of screen
1 OR $58 ;
1 OR $50 ; $58, $59 or $5A.
1 OR $40 ; add the base address of screen.
1 OR $20 ; make variable lower-case.
1 OR $20 ; make lowercase - set bit 5.
1 OR $20 ; ensure it is upper-case.
1 OR $20 ; convert to range 1 - 26.
1 OR $20 ; convert to lower-case
1 OR $08 ; set bit 3 - MIC off.
1 OR $02 ; combine with red border colour.
1 OR $08 ; bit 3 set (tape output bit on port #FE)
1 NOP ; These seem unnecessary.
1 NEG ; negative numbers are made positive
1 NEG ; Negate to give number of scrolls required.
1 NEG ; Negate the exponent.
1 NEG ; Negate as counter decrements from zero
1 LDIR ; ldir will clear lines.
1 LDIR ; from ROM to RAM.
1 LDIR ; else copy the bytes.
1 LDIR ; else copy bytes overwriting some spaces.
1 LDIR ; copy value into DEF FN statement
1 LDIR ; copy up to ten bytes
1 LDIR ; copy the five bytes.
1 LDIR ; copy string to workspace.
1 LDIR ; copy string from program or variables or
1 LDIR ; copy bytes.
1 LDIR ; copy bytes to set all attributes.
1 LDIR ; copy bytes scrolling the linear attributes.
1 LDIR ; copy bytes of line or variable into new area.
1 LDIR ; copy bytes (BC=0, H incremented, L=0)
1 LDIR ; copy bytes
1 LDIR ; copy a pixel line to previous third.
1 LDIR ; copy C bytes
1 LDIR ; Copy the bytes to RAM.
1 LDIR ; Copy five bytes to program location
1 LDIR ; Copy 'deleted' values to variable.
1 LDDR ; the program, variables, etc are moved up.
1 LDDR ; copy the BASIC line back to initial command.
1 LDDR ; copy of the standard characters A - U.
1 LDDR ; copy bytes from end to start.
1 LDDR ; copy bytes filling with spaces.
1 LDDR ; LDDR sets to zeros or spaces
1 LD SP,HL ; set up the machine stack pointer.
1 LD SP,HL ; initialize the machine stack pointer.
1 LD SP,HL ; else put error routine on stack
1 LD SP,($5C3F) ; set stack pointer to LIST_SP
1 LD SP,($5C3D) ; ERR_SP points to an error handler on the
1 LD L,E ; to the HL register.
1 LD L,E ; to end - just a one character slice.
1 LD L,E ; to HL.
1 LD L,E ; to HL for result.
1 LD L,E ; pair.
1 LD L,E ;
1 LD L,C ; to HL. e.g. a$(42 to 99)
1 LD L,C ; to HL register.
1 LD L,C ; to HL
1 LD L,C ; start to HL also.
1 LD L,C ; number to the HL register.
1 LD L,C ; line number to HL.
1 LD L,B ; load L with the line from B.
1 LD L,B ; dimensions to L since these require 16 bits
1 LD L,A ; will be next group of 8.
1 LD L,A ; transfer A to L
1 LD L,A ; store in L for later indexing.
1 LD L,A ; result to L
1 LD L,A ; place X value in L.
1 LD L,A ; low byte to L.
1 LD L,A ; low byte now correct.
1 LD L,A ; character to A
1 LD L,A ; and transfer to L.
1 LD L,A ; and store in L for indexing
1 LD L,A ; L a multiple of 32.
1 LD L,A ;
1 LD L,(IY+$0E) ; fetch BORDCR to L which is used for lower
1 LD L,(IX-$06) ; fetch length of old data
1 LD L,(IX+$0D) ; else use the destination in the header
1 LD L,(IX+$0D) ; else fetch the low byte.
1 LD L,(IX+$00) ; load currently addressed byte to L.
1 LD L,(HL) ; fetch the error code that follows.
1 LD L,$05 ; make elements 5 bytes as is numeric.
1 LD L,$00 ;
1 LD IY,$5C3A ; set IY to ERR_NR. IY can reach all standard
1 LD IX,<A href="#L03D1">L03D1</a> ; Address: BE-IX+3
1 LD IX,($5C5F) ; reload IX from adjusted X_PTR
1 LD IX,($5C5F) ; reload IX from X_PTR which will have been
1 LD I,A ; Set the I register - this remains constant
1 LD HL,<A href="#L3365">L3365</a> ; Address: RE-ENTRY
1 LD HL,<A href="#L32C5">L32C5</a> ; Address: stk-zero - start of table of
1 LD HL,<A href="#L2D2B">L2D2B</a> ; address: STACK-BC is
1 LD HL,<A href="#L27B0">L27B0</a> - $C3 ; $26ED is base of table
1 LD HL,<A href="#L2795">L2795</a> ; Address: $2795 - tbl-of-ops
1 LD HL,<A href="#L2596">L2596</a> ; Address: scan-func
1 LD HL,<A href="#L1C01">L1C01</a> ; address: class-tbl.
1 LD HL,<A href="#L1B76">L1B76</a> ; address: STMT-RET
1 LD HL,<A href="#L1A48">L1A48</a> ; address: offst-tbl
1 LD HL,<A href="#L177A">L177A</a> ; address: op-str-lu is loaded.
1 LD HL,<A href="#L1716">L1716</a> ; address: cl-str-lu in ROM.
1 LD HL,<A href="#L162D">L162D</a> ; address: chn-cd-lu
1 LD HL,<A href="#L15C6">L15C6</a> ; set source to ROM Address: init-strm
1 LD HL,<A href="#L1555">L1555</a> ; Address: REPORT-G
1 LD HL,<A href="#L1167">L1167</a> ; address: ED-FULL
1 LD HL,<A href="#L0FA0">L0FA0</a> - 7 ; base address of editing keys table. $0F99
1 LD HL,<A href="#L0F38">L0F38</a> ; address: ED-LOOP is loaded to HL.
1 LD HL,<A href="#L0A11">L0A11</a> - 6 ; address 0A0B - the base address of control
1 LD HL,<A href="#L053F">L053F</a> ; Address: SA/LD-RET
1 LD HL,<A href="#L046E">L046E</a> ; Address: semi-tone
1 LD HL,<A href="#L0284">L0284</a>-$30 ; $0254 - base of E-DIGITS
1 LD HL,<A href="#L0260">L0260</a>-$30 ; prepare base of table CTL-CODES.
1 LD HL,<A href="#L0246">L0246</a>-$41 ; Address: $0205 L0246-$41 EXT-SHIFT base
1 LD HL,($5CB4) ; now P-RAMT ($7FFF on 16K RAM machine)
1 LD HL,($5CB2) ; fetch RAMTOP to HL again as we've lost it.
1 LD HL,($5CB0) ; fetch the system variable NMIADD.
1 LD HL,($5C91) ; fetch P_FLAG
1 LD HL,($5C8F) ; pick up ATTR_T and MASK_T
1 LD HL,($5C8F) ; fetch current ATTR_T, MASK_T to HL.
1 LD HL,($5C8F) ; fetch L = ATTR_T, H = MASK-T
1 LD HL,($5C8F) ; L=ATTR_T, H=MASK_T
1 LD HL,($5C8D) ; fetch L=ATTR_P and H=MASK_P
1 LD HL,($5C8A) ; fetch updated SPOSNL
1 LD HL,($5C8A) ; fetch SPOSNL
1 LD HL,($5C86) ; Fetch display file address from DFCCL
1 LD HL,($5C84) ; Fetch DF_CC display file address
1 LD HL,($5C82) ; fetch ECHO_E
1 LD HL,($5C80) ; Fetch printer buffer address from PR_CC.
1 LD HL,($5C7B) ; Fetch UDG differs on 16K/48K machines.
1 LD HL,($5C78) ; Fetch the first two bytes at FRAMES1.
1 LD HL,($5C74) ; fetch T_ADDR
1 LD HL,($5C68) ; find start of variable contents from MEM.
1 LD HL,($5C68) ; fetch MEM the base of memory area.
1 LD HL,($5C68) ; MEM is base address of the memory cells.
1 LD HL,($5C65) ; set HL to STKEND location after value
1 LD HL,($5C65) ; make HL point to first empty location STKEND
1 LD HL,($5C65) ; fetch new STKEND the top destination.
1 LD HL,($5C65) ; fetch STKEND the start of free memory.
1 LD HL,($5C65) ; STKEND points to end of stack.
1 LD HL,($5C63) ; fetch STKBOT to HL as well
1 LD HL,($5C61) ; set HL to WORKSP - location after edit line.
1 LD HL,($5C61) ; point to end of line + 1 - WORKSP.
1 LD HL,($5C61) ; fetch WORKSP - end of line.
1 LD HL,($5C61) ; Fetch WORKSP.
1 LD HL,($5C5F) ; fetch stored CH_ADD value from X_PTR.
1 LD HL,($5C5F) ; fetch adjusted workspace pointer from X_PTR
1 LD HL,($5C5F) ; fetch X_PTR the original READ CH_ADD
1 LD HL,($5C5D) ; get current address from CH_ADD
1 LD HL,($5C5D) ; fetch CH_ADD - points to location after the
1 LD HL,($5C5D) ; fetch CH_ADD
1 LD HL,($5C5B) ; load address of cursor from K_CUR.
1 LD HL,($5C5B) ; load HL with end of string from K_CUR.
1 LD HL,($5C5B) ; fetch address of keyboard cursor from K_CUR
1 LD HL,($5C59) ; load HL with E_LINE.
1 LD HL,($5C59) ; fetch E_LINE
1 LD HL,($5C59) ; an editing error so address E_LINE.
1 LD HL,($5C59) ; address E_LINE.
1 LD HL,($5C59) ; address E_LINE in editing area.
1 LD HL,($5C59) ; address E_LINE - first location after
1 LD HL,($5C59) ; address E_LINE
1 LD HL,($5C57) ; load HL with Data Address DATADD, which is
1 LD HL,($5C55) ; fetch NXTLIN to HL.
1 LD HL,($5C53) ; load HL from system variable PROG
1 LD HL,($5C53) ; fetch start of program from PROG
1 LD HL,($5C53) ; fetch start of program area from PROG
1 LD HL,($5C51) ; fetch value of system variable CURCHL
1 LD HL,($5C51) ; fetch current channel CURCHL
1 LD HL,($5C51) ; fetch address of CURCHL - current channel.
1 LD HL,($5C51) ; fetch CURCHL to HL to address current channel
1 LD HL,($5C51) ; fetch CURCHL the current channel.
1 LD HL,($5C51) ; fetch CURCHL make HL address output routine.
1 LD HL,($5C51) ; address CURCHL
1 LD HL,($5C4F) ; fetch CHANS.
1 LD HL,($5C4F) ; fetch CHANS the location of the base of
1 LD HL,($5C4F) ; fetch CHANS address to HL
1 LD HL,($5C4D) ; reload HL with DEST.
1 LD HL,($5C4D) ; pick up pointer to end of string from DEST.
1 LD HL,($5C4D) ; load address of variable from DEST
1 LD HL,($5C4D) ; address DEST first character.
1 LD HL,($5C4B) ; load HL with VARS - start of variables area.
1 LD HL,($5C4B) ; load HL from system variable VARS
1 LD HL,($5C49) ; get current line from E_PPC
1 LD HL,($5C49) ; fetch E_PPC current edit line to HL.
1 LD HL,($5C49) ; fetch E_PPC - line number.
1 LD HL,($5C45) ; get the current line from PPC
1 LD HL,($5C45) ; Load with current line number from PPC
1 LD HL,($5C42) ; fetch line number from NEWPPC
1 LD HL,($5C36) ; fetch address of CHARS.
1 LD HL,($5C0E) ; TVDATA gives control code and possible
1 LD HL,($5C0B) ; get original DEFADD address
1 LD HL,$FFF6 ; prepare the value minus ten.
1 LD HL,$FFF0 ; prepare minus seventeen.
1 LD HL,$FFE0 ; set HL to the 16-bit value -32.
1 LD HL,$FFE0 ; load the value -32.
1 LD HL,$F8E0 ; subtract $08 from H and add $E0 to L -
1 LD HL,$D8F0 ; load HL with value -9999
1 LD HL,$5CB6 ; The address of the channels - initially
1 LD HL,$5CAC ; address MEM-5-1 the leading digits counter.
1 LD HL,$5CAB ; address MEM-5-1 leading digit counter
1 LD HL,$5CAA ; set HL to mem-4-5th last byte of buffer
1 LD HL,$5CA6 ; address MEM-4-0 byte destination.
1 LD HL,$5CA1 ; set HL to start of digits at MEM-3-1
1 LD HL,$5CA1 ; address MEM-3 start of digits
1 LD HL,$5CA1 ; MEM-3
1 LD HL,$5C92 ; use MEM-0 as a temporary calculator stack
1 LD HL,$5C92 ; normal location of MEM-0
1 LD HL,$5C92 ; address MEM-0
1 LD HL,$5C92 ; MEM-0: number stored here is in 16 bit integer format (pitch)
1 LD HL,$5C91 ; point to P_FLAG.
1 LD HL,$5C91 ; address system variable P_FLAG
1 LD HL,$5C91 ; address P_FLAG.
1 LD HL,$5C91 ; address P_FLAG
1 LD HL,$5C90 ; point to MASK_T
1 LD HL,$5C8F ; address ATTR_T
1 LD HL,$5C89 ; address S_POSN_hi - line
1 LD HL,$5C71 ; point to system variable FLAGX
1 LD HL,$5C71 ; address system variable FLAGX
1 LD HL,$5C6C ; fetch S_TOP the rough estimate.
1 LD HL,$5C6B ; address DF_SZ
1 LD HL,$5C6A ; point to FLAGS2
1 LD HL,$5C67 ; address BREG in system variables
1 LD HL,$5C4B ; address VARS the first of the
1 LD HL,$5C4A ; set HL to E_PPC_hi as next routine stores
1 LD HL,$5C49 ; address E_PPC - 'current line'
1 LD HL,$5C44 ; set source top to NSPPC next statement.
1 LD HL,$5C41 ; address the MODE system variable.
1 LD HL,$5C3B ; point to FLAGS.
1 LD HL,$5C3B ; point to FLAGS
1 LD HL,$5C3B ; make HL address FLAGS
1 LD HL,$5C3B ; fetch FLAGS
1 LD HL,$5C3B ; address system variable FLAGS
1 LD HL,$5C10 ; address STRMS - the start of the streams
1 LD HL,$5B00 ; the base address of the Printer Buffer.
1 LD HL,$5AC0 ; set initial attribute address to the leftmost
1 LD HL,$4000 ; set start to display file start.
1 LD HL,$3C00 ; a strange place to set the pointer to the
1 LD HL,$1F80 ; a timing constant H=$1F, L=$80
1 LD HL,$1A90 ; set the pitch - or tone period.
1 LD HL,$1A90 ; set pitch or tone period.
1 LD HL,$0C98 ; another timing value H=$0C, L=$98.
1 LD HL,$0523 ; The keyboard repeat and delay values are
1 LD HL,$0415 ; set up 16-bit outer loop counter for
1 LD HL,$00C8 ; and pitch.
1 LD HL,$0050 ; test against another 80 bytes
1 LD HL,$000A ; an overhead of ten bytes
1 LD HL,$0001 ; make elements one character presuming string
1 LD HL,$0001 ; explicit - inc hl would do.
1 LD HL,$0000 ; set destination to zero as not fixed.
1 LD HL,$0000 ; prepare to clear some system variables.
1 LD HL,$0000 ; initialize result to zero
1 LD H,D ; transfer the address
1 LD H,D ; transfer start of filename
1 LD H,D ; transfer DE space + 1 from make-room
1 LD H,D ; copy start
1 LD H,C ; set H to zero - from last LDIR.
1 LD H,B ; transfer size
1 LD H,B ; transfer second parameter
1 LD H,B ; transfer line number
1 LD H,B ; transfer line
1 LD H,B ;
1 LD H,A ; transfer the modified
1 LD H,A ; transfer row bits to H
1 LD H,A ; transfer high byte to H.
1 LD H,A ; set H, MASK P, to 00000000.
1 LD H,A ; save high byte of attributes.
1 LD H,A ; high byte correct.
1 LD H,A ; and store back in parity register.
1 LD H,A ; and reset address.
1 LD H,A ; and place y value in high byte.
1 LD H,A ; HL now has the correct address.
1 LD H,A ; HL is now correct
1 LD H,A ;
1 LD H,(IY+$0D) ; fetch statement from SUBPPC and
1 LD H,(IX-$05) ; to HL.
1 LD H,(IX-$05) ; the first header.
1 LD H,(IX+$0E) ; fetch high byte of autostart line number.
1 LD H,(IX+$0E) ; and load code at address saved from.
1 LD H,(HL) ; and store in H
1 LD H,$FF ; disable limit check by setting HL high
1 LD H,$5C ; now form the address in STRMS area.
1 LD H,$00 ; zero high byte.
1 LD H,$00 ; trailing spaces
1 LD H,$00 ; set up parity byte as zero.
1 LD H,$00 ; set high byte to zero
1 LD H,$00 ; prepare to index
1 LD E,L ; to DE.
1 LD E,L ; the DE register pair.
1 LD E,L ; copy HL
1 LD E,D ; but first switch
1 LD E,D ;
1 LD E,C ; to DE overwriting 0001.
1 LD E,C ; copy C to E (D is 0)
1 LD E,C ; DE = #cycles
1 LD E,B ; set E to 0
1 LD E,A ; transfer the new key to E
1 LD E,A ; to give the low byte of top line
1 LD E,A ; sign byte to E.
1 LD E,A ; save first in E
1 LD E,A ; place in E for sign
1 LD E,A ; place in E
1 LD E,A ; now transfer to DE
1 LD E,A ; main key to A
1 LD E,A ; control character 06 - 23d
1 LD E,A ; and store result in E
1 LD E,(IY-$02) ; use RASP value.
1 LD E,(IY-$02) ; fetch RASP value.
1 LD E,(IY-$01) ; on PIP value for duration.
1 LD E,(IY+$2D) ; fetch BREG - the count of scroll lines to E.
1 LD E,(IX+$0B) ; fetch length of new data
1 LD E,(IX+$0B) ; fetch length of bytes from the
1 LD E,(HL) ; to E
1 LD E,(HL) ; pick up the low byte.
1 LD E,(HL) ; offset to E
1 LD E,(HL) ; low byte of line number to E.
1 LD E,(HL) ; low byte of line length to E.
1 LD E,(HL) ; in DE.
1 LD E,(HL) ; fetch the offset to routine.
1 LD E,(HL) ; fetch offset to E
1 LD E,(HL) ; fetch low byte of CHANS offset
1 LD E,$FF ; signal 'no leading zeros'.
1 LD E,$F3 ; search will be for token 'NEXT'
1 LD E,$E4 ; token 'DATA'
1 LD E,$99 ; reset bit 6 and substitute $19 'usr-$'
1 LD E,$20 ; signal 'output leading spaces'
1 LD E,$00 ; set E to zero to suppress token searching
1 LD DE,<A href="#L168F">L168F</a> ; DE to LINE-ZERO should HL also fail.
1 LD DE,<A href="#L15AF">L15AF</a> ; Address: init-chan in ROM.
1 LD DE,<A href="#L1539">L1539</a> - 1 ; the message table directly.
1 LD DE,<A href="#L1537">L1537</a> - 1 ; address the comma and space message.
1 LD DE,<A href="#L1391">L1391</a> ; address: rpt-mesgs.
1 LD DE,<A href="#L110D">L110D</a> ; address: KEY-NEXT will be next input stream
1 LD DE,<A href="#L10A8">L10A8</a> ; fetch address KEY-INPUT for second pass
1 LD DE,<A href="#L10A8">L10A8</a> ; address: KEY-INPUT will be next input stream
1 LD DE,<A href="#L0DD9">L0DD9</a> ; set DE to address: CL-SET
1 LD DE,<A href="#L0CF8">L0CF8</a> ; make DE address: scrl-mssg
1 LD DE,<A href="#L09F4">L09F4</a> ; set address to PRINT-OUT for first pass.
1 LD DE,<A href="#L09F4">L09F4</a> ; address: PRINT-OUT
1 LD DE,<A href="#L09C0">L09C0</a> ; address base of last 4 tape messages
1 LD DE,<A href="#L09A1">L09A1</a> ; address: tape-msgs
1 LD DE,($5CB2) ; Fetch RAMTOP as top value.
1 LD DE,($5C8F) ; make D hold ATTR_T, E hold MASK-T
1 LD DE,($5C8A) ; fetch SPOSNL.
1 LD DE,($5C6C) ; fetch S_TOP to DE, the current top line
1 LD DE,($5C65) ; set DE to STKEND
1 LD DE,($5C61) ; fetch WORKSP to DE
1 LD DE,($5C61) ; WORKSP points to the beginning.
1 LD DE,($5C5F) ; fetch adjusted workspace pointer from X_PTR
1 LD DE,($5C59) ; address the start of line E_LINE.
1 LD DE,($5C53) ; fetch the address of PROG
1 LD DE,($5C53) ; fetch PROG to DE.
1 LD DE,($5C4B) ; fetch VARS
1 LD DE,($5C38) ; Fetch RASP/PIP.
1 LD DE,$FFFF ; a buffer to receive 2 keys.
1 LD DE,$FFFF ; Set pointer to top of possible physical RAM.
1 LD DE,$FFFB ; the value -5
1 LD DE,$A3E2 ; the number of bytes from stream 4, $5C1E,
1 LD DE,$5CA1 ; address MEM-3-0 nibble source.
1 LD DE,$5C92 ; MEM-0 is location of 8 bytes of character
1 LD DE,$5C70 ; address OSPPC - statement for CONTINUE.
1 LD DE,$5C10 ; set destination to system variable STRMS-FD
1 LD DE,$5AE0 ; start of last 'line' of attribute area
1 LD DE,$3EAF ; address of last byte of 'U' bitmap in ROM.
1 LD DE,$0701 ; now address next third adjusting
1 LD DE,$02C0 ; prepare known number of characters in
1 LD DE,$0200 ; the search is to be for the end of the
1 LD DE,$0200 ; count 1+1 statements, dummy value in E to
1 LD DE,$0100 ; fetch offset to chr$ 32
1 LD DE,$0032 ; allow for another 50 bytes.
1 LD DE,$0011 ; there are seventeen bytes.
1 LD DE,$0011 ; seventeen bytes
1 LD DE,$000F ; add 3*5 to
1 LD DE,$0008 ; and prepare to add 8.
1 LD DE,$0006 ; six bytes forward points to loc past value.
1 LD DE,$0005 ; each numeric element is 5 bytes.
1 LD DE,$0001 ; the result will be 1.
1 LD DE,$0001 ; default the start point to position 1.
1 LD DE,$0000 ; put zero in D, to suppress line cursor.
1 LD DE,$0000 ; initialize 16 bit buffer register.
1 LD DE,$0000 ; dummy value for STKEND at start of ROM
1 LD DE,$0000 ;
1 LD D,H ; transfer address to
1 LD D,H ; transfer HL, the last value, to DE.
1 LD D,H ; to DE.
1 LD D,H ; set DE to point to last location.
1 LD D,H ; copy HL
1 LD D,E ; transfer a possible previous key to D
1 LD D,C ; LSB to D
1 LD D,B ; transfer the start
1 LD D,A ; transfer to high byte.
1 LD D,A ; transfer now to D
1 LD D,A ; transfer count to D
1 LD D,A ; the two keys.
1 LD D,A ; store statement in D.
1 LD D,A ; save the mask to control the printer later.
1 LD D,A ; save literal in D
1 LD D,A ; save line in D for later.
1 LD D,A ; save current character
1 LD D,A ; save character in D
1 LD D,A ; register DE now holds start address of cell.
1 LD D,A ; place in D
1 LD D,A ; load D with zero to form the displacement
1 LD D,A ; Store result in D.
1 LD D,A ; Counter to D
1 LD D,(IY+$36) ; fetch OSPPC statement.
1 LD D,(IY+$0D) ; fetch statement from SUBPPC system variable.
1 LD D,(IY+$01) ; post-SCANNING FLAGS to D
1 LD D,(IY+$01) ; pick up FLAGS (3 bytes)
1 LD D,(IX+$0C) ; to DE.
1 LD D,(IX+$0C) ; from 2nd descriptor.
1 LD D,(IX+$0C) ; descriptor.
1 LD D,(HL) ; to D
1 LD D,(HL) ; reload the high byte.
1 LD D,(HL) ; put the high byte to D.
1 LD D,(HL) ; high byte of line number to D.
1 LD D,(HL) ; high byte of line length to D.
1 LD D,(HL) ; get line
1 LD D,(HL) ; fetch to D
1 LD D,(HL) ; fetch high byte.
1 LD D,(HL) ; fetch high byte of the system variable.
1 LD D,(HL) ; fetch high byte of offset
1 LD D,$40 ; signal numeric in D.
1 LD D,$3E ; prepare cursor '>' in D.
1 LD D,$00 ; signal string.
1 LD D,$00 ; set statement to 0 - first.
1 LD D,$00 ; prepare to add.
1 LD D,$00 ; prepare to add
1 LD D,$00 ; prepare for beeper.
1 LD D,$00 ; prepare for addition
1 LD D,$00 ; is transferred to DE.
1 LD D,$00 ; initialize statement counter to zero.
1 LD D,$00 ; and reset D to index into main table
1 LD D,$00 ; and give a short click based
1 LD C,L ;(4) ; C = medium part of tone period
1 LD C,L ; to the BC register.
1 LD C,L ; to register BC.
1 LD C,L ; to be moved.
1 LD C,L ; to BC.
1 LD C,L ; to BC register.
1 LD C,L ; to BC
1 LD C,L ; the BC register pair
1 LD C,L ; save L in C low byte
1 LD C,L ; length to old length.
1 LD C,L ; in BC.
1 LD C,L ; and create
1 LD C,H ; transfer to
1 LD C,E ; to BC register pair.
1 LD C,E ; to BC
1 LD C,E ; from DE to BC.
1 LD C,E ; and points to start of data in variable.
1 LD C,D ; exponent to C
1 LD C,D ; column to C (0-31d)
1 LD C,B ; MSB to C
1 LD C,B ; B is now zero, so BC now zero.
1 LD C,A ;(4) ; save port #FE output byte
1 LD C,A ; transfer to C
1 LD C,A ; transfer the low byte to A.
1 LD C,A ; transfer the current character to C.
1 LD C,A ; transfer result to sign byte.
1 LD C,A ; transfer byte count to C ($E0 at most)
1 LD C,A ; transfer INVERSE mask to C
1 LD C,A ; transfer 'function' to C
1 LD C,A ; store the sign byte in the C register.
1 LD C,A ; store the new long-term byte.
1 LD C,A ; store result in C
1 LD C,A ; store part in C
1 LD C,A ; store parameter in C.
1 LD C,A ; store in C.
1 LD C,A ; store in C as an intermediate value.
1 LD C,A ; store exponent in C
1 LD C,A ; save result in C
1 LD C,A ; restore long-term port state.
1 LD C,A ; put the valid command code back in C.
1 LD C,A ; put modified comparison operator back
1 LD C,A ; possible operator to C
1 LD C,A ; positive exponent to C
1 LD C,A ; place the result in the low byte.
1 LD C,A ; place result, zero or -118, in C.
1 LD C,A ; place it in C.
1 LD C,A ; load C with $21
1 LD C,A ; copy to C also.
1 LD C,A ; and transfer to C.
1 LD C,A ; and to C
1 LD C,A ; and store initial state long-term in C.
1 LD C,A ; and store in C.
1 LD C,A ; and store in C
1 LD C,A ; and store back in register C.
1 LD C,A ; and put back in C for long-term.
1 LD C,A ; and place in column register.
1 LD C,(IY+$71) ; MEM-5-1st No. of digits to C
1 LD C,(IY+$71) ; MEM-5-1st
1 LD C,(IY+$57) ; P_FLAG to C
1 LD C,(IY+$0D) ; then SUBPPC for statement
1 LD C,(IY+$07) ; pick up MODE (3 bytes)
1 LD C,(IX+$0F) ; fetch length of BASIC on tape
1 LD C,(IX+$0B) ; get new length
1 LD C,(IX+$0B) ; fetch new data length
1 LD C,(HL) ; transfer to base line of upper part
1 LD C,(HL) ; transfer to C.
1 LD C,(HL) ; transfer to C and
1 LD C,(HL) ; transfer to C
1 LD C,(HL) ; transfer the offset to C.
1 LD C,(HL) ; to C
1 LD C,(HL) ; place in C
1 LD C,(HL) ; pick up the letter.
1 LD C,(HL) ; pick up displacement to syntax table entry.
1 LD C,(HL) ; pick it up in C.
1 LD C,(HL) ; operation code to C ( B is still zero )
1 LD C,(HL) ; low byte to C.
1 LD C,(HL) ; low byte to C
1 LD C,(HL) ; low byte of line length to C.
1 LD C,(HL) ; low byte of displacement to C.
1 LD C,(HL) ; fetch the displacement to opening routine.
1 LD C,(HL) ; fetch sign to C
1 LD C,(HL) ; fetch offset from table and make B zero.
1 LD C,(HL) ; fetch low byte of routine
1 LD C,(HL) ; each byte of first
1 LD C,(HL) ; displacement to BC
1 LD C,(HL) ; C = pos/neg flag = 0/FF
1 LD C,$FF ; set a flag to indicate when a significant
1 LD C,$FF ; prepare negative sign byte and
1 LD C,$F6 ; value -10 ( B is still $FF )
1 LD C,$F6 ; set C to minus ten - will count characters
1 LD C,$80 ; C has bit 7 set to indicate type mismatch as
1 LD C,$3F ;(7) ;
1 LD C,$22 ; else double length to thirty four.
1 LD C,$21 ; the leftmost column position.
1 LD C,$21 ; set the column position .
1 LD C,$21 ; set column of upper screen to leftmost.
1 LD C,$21 ; set C to $21 (was $21 from above routine)
1 LD C,$21 ; make column $21. (No use is made of this)
1 LD C,$20 ; set count to 32 bytes.
1 LD C,$12 ; set BC to eighteen locations.
1 LD C,$0D ; otherwise an additional 13 bytes are needed.
1 LD C,$0A ; ten bytes to move
1 LD C,$08 ; there are eight screen lines to a text line.
1 LD C,$08 ; there are 8 pixel lines to scroll.
1 LD C,$05 ; set byte count to 5 - 10 nibbles
1 LD C,$05 ; result is five locations lower
1 LD C,$04 ; four bytes for top/bottom half
1 LD C,$03 ; increase space to three bytes for the
1 LD C,$02 ; the rightmost column position.
1 LD C,$01 ; set C length to one
1 LD C,$01 ; prepare a positive sign byte.
1 LD C,$00 ; the length of an empty string
1 LD C,$00 ; set flag to zero indicating that any
1 LD C,$00 ; initialize quotes flag
1 LD C,$00 ;
1 LD BC,<A href="#L1B52">L1B52</a> ; address: SCAN-LOOP
1 LD BC,<A href="#L15C6">L15C6</a> + 14 ; prepare the address of the byte after
1 LD BC,($5CB4) ; Fetch P-RAMT differs on 16K/48K machines.
1 LD BC,($5CB2) ; use the existing value of RAMTOP if zero.
1 LD BC,($5CAB) ; set C to MEM-5-1st digit counter.
1 LD BC,($5C8A) ; Fetch line/column from SPOSNL
1 LD BC,($5C88) ; fetch S_POSN to BC.
1 LD BC,($5C88) ; fetch S_POSN current line/column of
1 LD BC,($5C88) ; Fetch line/column from S_POSN
1 LD BC,($5C82) ; fetch line and column from ECHO_E
1 LD BC,($5C7B) ; fetch the UDG system variable value.
1 LD BC,($5C7B) ; fetch UDG to address bit patterns
1 LD BC,($5C78) ; use the lower two bytes at FRAMES1.
1 LD BC,($5C76) ; fetch system variable SEED
1 LD BC,($5C72) ; fetch STRLEN to BC.
1 LD BC,($5C66) ; STKEND_hi
1 LD BC,($5C55) ; fetch NXTLIN
1 LD BC,($5C45) ; fetch the current line number from PPC
1 LD BC,($5C45) ; fetch PPC the current line number.
1 LD BC,($5C36) ; address CHARS
1 LD BC,$FFFB ; the value -5
1 LD BC,$FF9C ; value -100
1 LD BC,$FEFE ; the commencing port address
1 LD BC,$3B0E ; B=$3B time(*), C=$0E, YELLOW, MIC OFF.
1 LD BC,$1821 ; reset column and line to 0,0
1 LD BC,$1721 ; line 23 for lower screen
1 LD BC,$1018 ; prepare priority $10, operation code 'val$' -
1 LD BC,$04F0 ; prepare priority $04, operation $C0 +
1 LD BC,$00A8 ; there are 21 user defined graphics.
1 LD BC,$0040 ; set the values of
1 LD BC,$0020 ; thirty-two bytes are to be copied.
1 LD BC,$0015 ; There are 21 bytes of initial data in ROM.
1 LD BC,$0014 ; a 20-byte overhead memory check.
1 LD BC,$0011 ; presume seventeen bytes for a header.
1 LD BC,$0011 ; prepare to add seventeen
1 LD BC,$000E ; copy the 14 bytes of initial 7 streams data
1 LD BC,$000A ; else trim length to ten.
1 LD BC,$0006 ; the function requires six hidden bytes for
1 LD BC,$0006 ; six locations required
1 LD BC,$0006 ; prepare to strip six bytes
1 LD BC,$0006 ; add six to HL
1 LD BC,$0005 ; start of number is five bytes before.
1 LD BC,$0005 ; length of number
1 LD BC,$0005 ; five bytes to move
1 LD BC,$0005 ; assume numeric and assign an initial 5 bytes
1 LD BC,$0005 ; an overhead of five bytes
1 LD BC,$0002 ; prepare for ink/paper etc.
1 LD BC,$0001 ; one space required.
1 LD BC,$0001 ; of character to be deleted.
1 LD BC,$0001 ; make room for one character
1 LD BC,$0001 ; make one space in workspace.
1 LD BC,$0001 ; initialize space required to one for
1 LD BC,$0000 ; this seems unnecessary.
1 LD BC,$0000 ; the stream is to be blanked.
1 LD BC,$0000 ; prepare to set DATADD to first line.
1 LD BC,$0000 ; initialize length of string to zero.
1 LD BC,$0000 ; initialize length of string to zero
1 LD BC,$0000 ; default the length result to zero.
1 LD B,H ;(4) ; B = coarse part of tone period
1 LD B,H ; transfer to BC
1 LD B,H ; transfer to
1 LD B,H ; transfer the length to
1 LD B,H ; transfer the length
1 LD B,H ; transfer result
1 LD B,H ; transfer it to
1 LD B,H ; transfer adjusted value
1 LD B,H ; transfer HL - cursor address
1 LD B,H ; total space
1 LD B,H ; to give number of data bytes
1 LD B,H ; otherwise set
1 LD B,H ; line to H (0-23d)
1 LD B,H ; and save result
1 LD B,D ; transfer the length (final dimension size)
1 LD B,D ; transfer int
1 LD B,D ; set B exponent to 0
1 LD B,D ; register DE has advanced past all dimensions
1 LD B,C ; set B to 5 counter
1 LD B,C ; load B with now trailing digit counter.
1 LD B,C ; No. of digits to B counter
1 LD B,A ; zero count to B
1 LD B,A ; transfer to mask
1 LD B,A ; transfer to B register
1 LD B,A ; transfer line to B
1 LD B,A ; the line number from top of screen to B.
1 LD B,A ; set count to 256 bytes.
1 LD B,A ; save the count in B.
1 LD B,A ; save statement in B.??
1 LD B,A ; save result in B.
1 LD B,A ; save in B
1 LD B,A ; save count in B.
1 LD B,A ; save character in B
1 LD B,A ; save character
1 LD B,A ; preserve A in B.
1 LD B,A ; place in line register
1 LD B,A ; pixel position to B, 0-7.
1 LD B,A ; load mask to B
1 LD B,A ; last byte not used
1 LD B,A ; else negative count now +ve
1 LD B,A ; count to B
1 LD B,A ; and make a copy in B.
1 LD B,A ; and line to one above lower screen.
1 LD B,A ; and B.
1 LD B,A ; and B, the syntax dimension counter (256)
1 LD B,A ; also does as an initial slight counter value.
1 LD B,(IY+$38) ; get single-character name from STRLEN_lo
1 LD B,(IY+$31) ; fetch lower screen display file size DF_SZ
1 LD B,(IY+$31) ; fetch DF_SZ to B.
1 LD B,(IY+$31) ; fetch DF_SZ to B
1 LD B,(IX+$10) ; from 2nd descriptor
1 LD B,(IX+$0C) ; of data block on tape.
1 LD B,(IX+$0C) ; from 2nd header.
1 LD B,(IX+$0C) ; from 2nd header
1 LD B,(HL) ; transfer to B overwriting zero.
1 LD B,(HL) ; transfer that to B
1 LD B,(HL) ; to B
1 LD B,(HL) ; priority to B.
1 LD B,(HL) ; place in B
1 LD B,(HL) ; indicator to B
1 LD B,(HL) ; high byte of line number to B
1 LD B,(HL) ; high byte of displacement to B.
1 LD B,(HL) ; fetch old value
1 LD B,(HL) ; fetch high byte of routine.
1 LD B,(HL) ; B = LSB, two's complement
1 LD B,$FF ; prepare OVER mask in B.
1 LD B,$DF ;
1 LD B,$B2 ; timing.
1 LD B,$B0 ; top 176 lines.
1 LD B,$B0 ; timing.
1 LD B,$B0 ; reset the B timer byte.
1 LD B,$A4 ; hold count. also timed instruction.
1 LD B,$91 ; set exponent byte +ve $81
1 LD B,$89 ; reduce the initial exponent by eight.
1 LD B,$80 ; mask for flash 10000000
1 LD B,$60 ; there are 96 characters in ASCII set.
1 LD B,$42 ; set timed delay. (66 decimal)
1 LD B,$40 ; mask for bright 01000000
1 LD B,$3E ; set up delay
1 LD B,$3B ; a final delay.
1 LD B,$38 ; set paper mask 00111000
1 LD B,$37 ; another short timed delay.
1 LD B,$32 ; wait for a second - 50 interrupts.
1 LD B,$31 ; set up timing.
1 LD B,$2F ; another short timed delay.
1 LD B,$21 ;
1 LD B,$20 ; there are thirty two bytes
1 LD B,$18 ; set count to whole display ??
1 LD B,$18 ; There are 24 lines.
1 LD B,$10 ; set B, bit counter, to 16d
1 LD B,$10 ; set B to 16
1 LD B,$10 ; priority $10 for all the rest
1 LD B,$0B ; set counter to eleven.
1 LD B,$0A ; the count will be ten characters for the
1 LD B,$09 ; the count is 9 (not ten) as the first
1 LD B,$08 ; set count to 8 lines of 32 bytes.
1 LD B,$08 ; count the bits.
1 LD B,$08 ; and reduce the bit counter to 8.
1 LD B,$08 ;
1 LD B,$07 ; set ink mask 00000111
1 LD B,$07 ; set B to 7, C is zero.
1 LD B,$07 ; count seven more bytes
1 LD B,$04 ; set bit 2 of mask for inverse.
1 LD B,$01 ; prepare OVER mask setting bit 0.
1 LD B,$01 ; load B with 1.
1 LD B,$01 ; continue to clear the bottom line.
1 LD B,$00 ; signal negate required before joining
1 LD B,$00 ; set high byte to zero.
1 LD B,$00 ; set high byte to 0, prepare for ldir.
1 LD B,$00 ; set B to zero for later indexing.
1 LD B,$00 ; priority marker zero is pushed on stack
1 LD B,$00 ; prepare to index into the class table.
1 LD B,$00 ; prepare to copy
1 LD B,$00 ; prepare to add offset.
1 LD B,$00 ; prepare to add
1 LD B,$00 ; make the high byte zero.
1 LD B,$00 ; make B zero
1 LD B,$00 ; limited to 127
1 LD B,$00 ; initialize dimensions to zero and
1 LD B,$00 ; but here if it was found in table so
1 LD B,$00 ; and make B zero
1 LD B,$00 ;
1 LD A,L ; the stored control code
1 LD A,L ; remainder to A.
1 LD A,L ; load the initial key value to A
1 LD A,L ; destination registers.
1 LD A,L ; consider low byte first.
1 LD A,H ; transfer to A
1 LD A,H ; test the destination for zero
1 LD A,H ; test for
1 LD A,H ; test address
1 LD A,H ; save H in A high byte
1 LD A,H ; now find the corresponding attribute byte
1 LD A,H ; high byte to A.
1 LD A,H ; fetch the running parity byte.
1 LD A,H ; fetch parity byte.
1 LD A,H ; compare high byte only
1 LD A,H ; check length of old
1 LD A,H ; Test if the result was zero.
1 LD A,H ;
1 LD A,E ; transfer to accumulator.
1 LD A,E ; old column to A
1 LD A,E ; now test E
1 LD A,E ; new operation to A register
1 LD A,E ; low byte to A as a useful return value.
1 LD A,E ; load least significant key from E
1 LD A,E ; fetch the operation code
1 LD A,E ; fetch low byte 00000001 00000001
1 LD A,D ;(4) ; one cycle of waveform has completed
1 LD A,D ; transfer parameter to A.
1 LD A,D ; transfer command bits to A.
1 LD A,D ; the high byte $00 - $27 is
1 LD A,D ; test that the stream is open.
1 LD A,D ; test if
1 LD A,D ; re-fetch parameter
1 LD A,D ; priority to A
1 LD A,D ; now test if D is still FF ?
1 LD A,D ; if there is no program then DE will
1 LD A,D ; high byte 00000000 00000000
1 LD A,D ; fetch the high byte D
1 LD A,D ; fetch the cursor.
1 LD A,D ; fetch parameter for INVERSE/OVER
1 LD A,D ; fetch original parameter 0,1 or 8
1 LD A,D ; fetch high byte
1 LD A,D ; check length of
1 LD A,D ; bring back the line to A.
1 LD A,D ; bring back compound literal
1 LD A,D ;
1 LD A,C ;(4) ; restore output byte for port #FE
1 LD A,C ; x value to A
1 LD A,C ; type to A
1 LD A,C ; transfer name/type to A.
1 LD A,C ; transfer line to A.
1 LD A,C ; transfer $F6 or $80 to A
1 LD A,C ; the x value 0-255.
1 LD A,C ; the new column number ($21) to C
1 LD A,C ; the column position. $21-$01
1 LD A,C ; stored exponent to A
1 LD A,C ; restore current character
1 LD A,C ; restore A
1 LD A,C ; line to A $00 - $17 (max 00010111)
1 LD A,C ; first value to A
1 LD A,C ; fetch value
1 LD A,C ; fetch type - should be 011xxxxx
1 LD A,C ; fetch the length, one or three.
1 LD A,C ; fetch the character back
1 LD A,C ; fetch lower priority operation code
1 LD A,C ; fetch long-term mask from C
1 LD A,C ; fetch comparison value.
1 LD A,C ; fetch byte with stored carry
1 LD A,C ; copy letter/flags to A
1 LD A,C ; column to A range 00000000 to 00011111
1 LD A,C ; bring back intermediate result from C
1 LD A,C ; and to A
1 LD A,C ; and test if carriage return only
1 LD A,B ; transfer to A
1 LD A,B ; transfer the line to A.
1 LD A,B ; transfer the line to A (1-24).
1 LD A,B ; transfer scroll number to A.
1 LD A,B ; transfer line to A.
1 LD A,B ; test value for zero and reject
1 LD A,B ; test this one
1 LD A,B ; test this
1 LD A,B ; test the length
1 LD A,B ; test that it is not
1 LD A,B ; test now if initial or residual length
1 LD A,B ; test length
1 LD A,B ; test if the number of
1 LD A,B ; test if length
1 LD A,B ; test for zero which
1 LD A,B ; test for
1 LD A,B ; store line count to A
1 LD A,B ; second value
1 LD A,B ; save line in A (1-24)
1 LD A,B ; retrieve statement.
1 LD A,B ; restore A without affecting flags.
1 LD A,B ; re-fetch the line count.
1 LD A,B ; re-fetch copy (0-5)
1 LD A,B ; put current value of mask in A
1 LD A,B ; one to test
1 LD A,B ; is the length zero ?
1 LD A,B ; hi byte of length1 to A
1 LD A,B ; get line count.
1 LD A,B ; fetch the literal (either $1D or $18).
1 LD A,B ; fetch stored report code.
1 LD A,B ; fetch high byte of line number and
1 LD A,B ; fetch augmented timing value from B.
1 LD A,B ; else just use the mask (white)
1 LD A,B ; dimensions to A
1 LD A,B ; action flag $FF=abs, $00=neg.
1 LD A,B ; A = pitch + 60
1 LD A,B ; $FF=abs, $00=neg
1 LD A,B ;
1 LD A,(IX-$03) ; fetch letter name from old header.
1 LD A,(IX+$00) ; fetch type 0, 1 or 2.
1 LD A,(IX+$00) ; fetch loaded header type to A
1 LD A,(IX+$00) ; fetch incoming type
1 LD A,(IX+$00) ; else fetch type from tape.
1 LD A,(HL) ; use it to pick up current character.
1 LD A,(HL) ; until we find
1 LD A,(HL) ; the high byte of line number
1 LD A,(HL) ; sign to A, $00 or $FF
1 LD A,(HL) ; reload the first byte
1 LD A,(HL) ; reload next (or same) character
1 LD A,(HL) ; pick up the letter.
1 LD A,(HL) ; pick up the key decoded possibly in another
1 LD A,(HL) ; pick up the exponent ( - $50).
1 LD A,(HL) ; pick up the colour attribute.
1 LD A,(HL) ; pick up other mode value.
1 LD A,(HL) ; pick up main key value
1 LD A,(HL) ; pick up in A
1 LD A,(HL) ; pick up character.
1 LD A,(HL) ; pick up byte.
1 LD A,(HL) ; number and pick up in A.
1 LD A,(HL) ; next character
1 LD A,(HL) ; load the first character
1 LD A,(HL) ; load first byte to accumulator
1 LD A,(HL) ; get next literal
1 LD A,(HL) ; get high byte of line number.
1 LD A,(HL) ; get first of 5 bytes
1 LD A,(HL) ; get first byte.
1 LD A,(HL) ; fetch the following character
1 LD A,(HL) ; fetch the channel identifier.
1 LD A,(HL) ; fetch the byte following 'stk-data'
1 LD A,(HL) ; fetch the addressed character.
1 LD A,(HL) ; fetch temporary attribute as no change.
1 LD A,(HL) ; fetch screen byte to A
1 LD A,(HL) ; fetch name
1 LD A,(HL) ; fetch masked letter to A.
1 LD A,(HL) ; fetch mask to accumulator.
1 LD A,(HL) ; fetch low byte of length.
1 LD A,(HL) ; fetch it.
1 LD A,(HL) ; fetch it
1 LD A,(HL) ; fetch high byte of line number.
1 LD A,(HL) ; fetch first character and test for
1 LD A,(HL) ; fetch exponent of positive fractional number
1 LD A,(HL) ; fetch exponent of int x.
1 LD A,(HL) ; fetch exponent byte.
1 LD A,(HL) ; fetch exponent byte of D.
1 LD A,(HL) ; fetch exponent of the half arc to A.
1 LD A,(HL) ; fetch exponent
1 LD A,(HL) ; fetch existing attribute
1 LD A,(HL) ; fetch digit
1 LD A,(HL) ; fetch character.
1 LD A,(HL) ; fetch character
1 LD A,(HL) ; fetch byte from screen.
1 LD A,(HL) ; fetch byte
1 LD A,(HL) ; fetch adjacent character from source.
1 LD A,(HL) ; fetch addressed character
1 LD A,(HL) ; else pick up flag bits.
1 LD A,(HL) ; and transfer that
1 LD A,(HL) ; and load character.
1 LD A,(HL) ; First byte must be zero, otherwise
1 LD A,(HL) ; Fetch first, floating-point, exponent byte.
1 LD A,(DE) ; test first character of token
1 LD A,(DE) ; reload leftmost character
1 LD A,(DE) ; pick up the first character.
1 LD A,(DE) ; pick up previous in A
1 LD A,(DE) ; of the test
1 LD A,(DE) ; get attribute for last line
1 LD A,(DE) ; first byte of screen to A
1 LD A,(DE) ; fetch workspace character.
1 LD A,(DE) ; fetch the low byte of program line number.
1 LD A,(DE) ; fetch the character
1 LD A,(DE) ; fetch next character
1 LD A,(DE) ; fetch existing destination byte
1 LD A,(DE) ; fetch character.
1 LD A,(DE) ; fetch character of first string.
1 LD A,(DE) ; fetch character
1 LD A,(DE) ; else fetch the first character.
1 LD A,(DE) ; byte to A
1 LD A,(DE) ; Re-fetch character from table.
1 LD A,(DE) ; Fetch exponent of the length indicator.
1 LD A,(BC) ; load contents into A register.
1 LD A,($5CAC) ; fetch total MEM-5-1
1 LD A,($5CAB) ; fetch digit count from MEM-5-1st
1 LD A,($5C91) ; fetch P_FLAG to accumulator
1 LD A,($5C91) ; P_FLAG
1 LD A,($5C8D) ; fetch permanent attribute from ATTR_P.
1 LD A,($5C8D) ; fetch ATTR_P - permanent attributes
1 LD A,($5C7E) ; Fetch System Variable COORDS-y
1 LD A,($5C7E) ; COORDS-y last y (integer iy 0-175)
1 LD A,($5C7E) ; COORDS-y
1 LD A,($5C7D) ; Fetch System Variable COORDS-x
1 LD A,($5C7D) ; COORDS-x last x (integer ix 0-255)
1 LD A,($5C7D) ; COORDS-x
1 LD A,($5C74) ; fetch reduced command from T_ADDR
1 LD A,($5C74) ; fetch T_ADDR
1 LD A,($5C74) ; else fetch the command from T_ADDR.
1 LD A,($5C74) ; T_ADDR_lo to accumulator.
1 LD A,($5C71) ; load accumulator from FLAGX
1 LD A,($5C6B) ; fetch DF_SZ the display file size of
1 LD A,($5C6B) ; fetch DF_SZ lower display file size.
1 LD A,($5C6A) ; fetch FLAGS2.
1 LD A,($5C67) ; load accumulator from system variable BREG
1 LD A,($5C48) ; fetch border colour from BORDCR.
1 LD A,($5C48) ; else lower screen uses BORDCR as attribute.
1 LD A,($5C48) ; BORDCR
1 LD A,($5C47) ; fetch current statement from SUBPPC
1 LD A,($5C44) ; load statement to A from NSPPC.
1 LD A,($5C44) ; fetch new statement from NSPPC
1 LD A,($5C41) ; fetch MODE 0='KLC', 1='E', 2='G'.
1 LD A,($5C3B) ; load accumulator from FLAGS
1 LD A,($5C3B) ; get FLAGS which has been set above
1 LD A,($5C3B) ; fetch system variable FLAGS.
1 LD A,($5C3B) ; fetch FLAGS value
1 LD A,($5C3A) ; fetch ERR_NR again
1 LD A,($5C3A) ; fetch ERR_NR
1 LD A,($5C0A) ; fetch the system variable value REPPER.
1 LD A,($5C09) ; pick up the system variable REPDEL
1 LD A,($5C08) ; system variable LASTK will hold last key -
1 LD A,$FF ; signal data not header.
1 LD A,$FF ; signal data not a header.
1 LD A,$FF ; signal data bytes.
1 LD A,$FF ; signal data as opposed to a header.
1 LD A,$FF ; select system channel 'R'.
1 LD A,$FF ; select system channel 'R'
1 LD A,$FF ; prepare XOR mask for sign bit
1 LD A,$FF ; Flag coming from NEW.
1 LD A,$FF ;
1 LD A,$FE ; Input address: $FEFE
1 LD A,$FE ; 11111110 in A.
1 LD A,$FD ; select system channel 'S'
1 LD A,$FD ; select system channel 'K'
1 LD A,$CE ; else load A with 'DEF FN' and
1 LD A,$CB ; the comparison byte.
1 LD A,$C6 ; two edges must be spaced apart.
1 LD A,$C0 ; test against the
1 LD A,$C0 ; set A 11000000 is xor mask for a long name.
1 LD A,$80 ; the endpoint of character set
1 LD A,$7F ; test the space key and
1 LD A,$7F ; read from port address $7FFE the
1 LD A,$7F ; prepare to read keyboard and EAR port
1 LD A,$5F ; substitute ASCII '_'
1 LD A,$4B ; prepare letter 'K'.
1 LD A,$45 ; prepare character 'e'
1 LD A,$43 ; alter 'L' to 'C'.
1 LD A,$3F ; load A with '?' the error marker.
1 LD A,$3F ; Load the accumulator with last page in ROM.
1 LD A,$3A ; then a ':' character.
1 LD A,$38 ; the colour system is set to white paper,
1 LD A,$2E ; prepare the character '.'
1 LD A,$2D ; the character '-'
1 LD A,$2D ; prepare character '-'
1 LD A,$22 ; value $21 is leftmost column.
1 LD A,$22 ; load the '"' character
1 LD A,$21 ; pre-load with leftmost position
1 LD A,$20 ; prepare leading space
1 LD A,$20 ; load A with 32 decimal
1 LD A,$20 ; followed by a space.
1 LD A,$20 ; Prepare the space character and continue to
1 LD A,$20 ;
1 LD A,$1F ; the value 31d
1 LD A,$19 ; subtract from twenty five
1 LD A,$19 ; compute scroll count as 25 minus
1 LD A,$18 ; reset
1 LD A,$18 ; <font color=#9900FF>Note.</font> This should be $19
1 LD A,$18 ;
1 LD A,$17 ; prepare the 'tab' control.
1 LD A,$16 ; prepare the 'at' control.
1 LD A,$16 ; 22 decimal
1 LD A,$10 ; initialize to 16d - INK.
1 LD A,$0F ; make the border white and mic off.
1 LD A,$0E ; fourteen variables to consider.
1 LD A,$0D ; prepare mic off - cyan
1 LD A,$0D ; prepare carriage return.
1 LD A,$0D ; prepare a carriage return
1 LD A,$08 ; value 00001000
1 LD A,$08 ; prepare to count 8 bytes
1 LD A,$08 ; load A with 8
1 LD A,$07 ; put 7 in accumulator
1 LD A,$07 ; Select a white border
1 LD A,$06 ; prepare the 'comma' control character.
1 LD A,$05 ; load accumulator with $05 and
1 LD A,$04 ; load A with the value 4.
1 LD A,$04 ; else stop the
1 LD A,$02 ; select red for border, microphone bit on.
1 LD A,$01 ; subtract the negated counter from 1
1 LD A,$01 ; select channel 'K' the keyboard for input.
1 LD A,$01 ; prepare blue, mic=on.
1 LD A,$01 ; default to type numeric.
1 LD A,$01 ;
1 LD A,$00 ; select lower screen again
1 LD A,$00 ; load accumulator with zero - without
1 LD A,$00 ; explicit - select channel zero.
1 LD (IY+$57),L ; and overwrite system variable P_FLAG.
1 LD (IY+$57),H ; and restore system variable P_FLAG.
1 LD (IY+$57),$01 ; temporarily set P_FLAG 'OVER 1'.
1 LD (IY+$52),$03 ; set SCR_CT to 3 lines.
1 LD (IY+$52),$01 ; set SCR_CT - scroll count - to default.
1 LD (IY+$46),L ; update PR_CC_lo - set to zero - superfluous.
1 LD (IY+$37),H ; clear all the bits of FLAGX.
1 LD (IY+$31),$02 ; set DF_SZ the lower screen display size to
1 LD (IY+$31),$02 ; now set DF_SZ lower screen to 2
1 LD (IY+$26),H ; blank X_PTR_hi to suppress error marker.
1 LD (IY+$26),$00 ; set X_PTR_hi so that iy is no longer relevant.
1 LD (IY+$26),$00 ; now nullify X_PTR_hi
1 LD (IY+$26),$00 ; make error pointer X_PTR_hi out of bounds
1 LD (IY+$0D),D ; set SUBPPC to decremented statement number.
1 LD (IY+$0A),D ; and statement in NSPPC
1 LD (IY+$0A),$FF ; set statement NSPPC to $FF signalling
1 LD (IY+$0A),$01 ; set NSPPC to one for first statement.
1 LD (IY+$0A),$00 ; set statement NSPPC to zero.
1 LD (IY+$07),$00 ; set MODE to 'KLC'
1 LD (IY+$02),$10 ; update TV_FLAG set bit 3
1 LD (IY+$00),$FF ; system variable ERR_NR is reset to 'OK'.
1 LD (IY+$00),$FF ; set ERR_NR to 'OK'.
1 LD (IY+$00),$FF ; set ERR_NR to 'OK' cancelling the error.
1 LD (IY+$00),$FF ; reset ERR_NR to 'OK'.
1 LD (IY+$00),$FF ; clear ERR_NR.
1 LD (IX+$10),H ; in the descriptor.
1 LD (IX+$0F),L ; place length of program
1 LD (IX+$0E),H ; the descriptor.
1 LD (IX+$0E),B ; line number in the descriptor.
1 LD (IX+$0E),B ; in descriptor.
1 LD (IX+$0E),$80 ; place high line number in descriptor to
1 LD (IX+$0D),L ; place start in
1 LD (IX+$0D),C ; place the auto-start
1 LD (IX+$0D),C ; place start
1 LD (IX+$0C),H ; in descriptor.
1 LD (IX+$0C),B ; in descriptor.
1 LD (IX+$0C),A ; to descriptor.
1 LD (IX+$0C),$1B ; to $1b00 to include bitmaps and attributes.
1 LD (IX+$0B),L ; place total length
1 LD (IX+$0B),C ; place length
1 LD (IX+$0B),A ; place in descriptor.
1 LD (IX+$0B),$00 ; set descriptor length
1 LD (IX+$01),$FF ; set first byte of ten character filename
1 LD (IX+$00),L ; place loaded byte at memory location.
1 LD (HL),E ; then low byte of line number.
1 LD (HL),E ; store low byte of length.
1 LD (HL),E ; save the looping line
1 LD (HL),E ; save low byte of line number.
1 LD (HL),E ; place E
1 LD (HL),E ; make it
1 LD (HL),E ; load low byte
1 LD (HL),E ; is made
1 LD (HL),E ; insert or overwrite the low byte.
1 LD (HL),E ; and update the input
1 LD (HL),D ; two locations.
1 LD (HL),D ; then high byte range $0 - $27 (1-9999).
1 LD (HL),D ; the next call to WAIT-KEY.
1 LD (HL),D ; store high byte.
1 LD (HL),D ; save high byte of line number.
1 LD (HL),D ; place D
1 LD (HL),D ; output address.
1 LD (HL),D ; load high byte
1 LD (HL),D ; insert or overwrite the high byte.
1 LD (HL),D ; and store the looping statement.
1 LD (HL),D ; address from DE.
1 LD (HL),C ; then store the sign byte
1 LD (HL),C ; then low byte of length.
1 LD (HL),C ; store each byte of second
1 LD (HL),C ; place zero (or low byte).
1 LD (HL),C ; place possible parameter. If only one
1 LD (HL),C ; insert that byte
1 LD (HL),C ; attributes.
1 LD (HL),B ; store the exponent
1 LD (HL),B ; place zero (or high byte).
1 LD (HL),B ; place code (ink etc.)
1 LD (HL),B ; insert high byte at position
1 LD (HL),B ; high byte last.
1 LD (HL),B ;
1 LD (HL),A ; zero to first byte
1 LD (HL),A ; zero to 2nd byte
1 LD (HL),A ; update system variable.
1 LD (HL),A ; update FLAGX
1 LD (HL),A ; then put back.
1 LD (HL),A ; store updated value.
1 LD (HL),A ; store the sign at correct location in
1 LD (HL),A ; store letter/type
1 LD (HL),A ; store counter
1 LD (HL),A ; reload into P_FLAG.
1 LD (HL),A ; put the decoded key in last location of map.
1 LD (HL),A ; put the altered adjusted number back
1 LD (HL),A ; put back result even if $0A.
1 LD (HL),A ; place the 5 registers.
1 LD (HL),A ; place in free location
1 LD (HL),A ; place in first new location.
1 LD (HL),A ; place back
1 LD (HL),A ; mask back to MASK_T system variable.
1 LD (HL),A ; load one or zero to low byte.
1 LD (HL),A ; inserting the new value.
1 LD (HL),A ; for subsequent repeats REPPER will be used.
1 LD (HL),A ; apply permanent bits to temporary bits.
1 LD (HL),A ; and update system variable
1 LD (HL),A ; and store updated value
1 LD (HL),A ; and store result in FLAGS2 again.
1 LD (HL),A ; and place attributes in next line up.
1 LD (HL),A ; and place a quote in second location.
1 LD (HL),A ; and insert that for first repeat delay.
1 LD (HL),A ; and insert character.
1 LD (HL),A ; and insert "No. of dims"
1 LD (HL),$FF ; else mark this particular map free.
1 LD (HL),$FF ;
1 LD (HL),$83 ; x, y, r, 2*PI.
1 LD (HL),$80 ; variables end-marker.
1 LD (HL),$80 ; place end-marker at end.
1 LD (HL),$80 ; holds end-marker $80
1 LD (HL),$80 ; an end-marker.
1 LD (HL),$80 ;
1 LD (HL),$3E ; top of user ram holds GOSUB end marker
1 LD (HL),$3E ; now put the GO SUB end-marker at RAMTOP.
1 LD (HL),$20 ; place a space there.
1 LD (HL),$20 ; place a space character in HL
1 LD (HL),$0E ; insert the 'hidden' marker.
1 LD (HL),$0E ; insert number marker
1 LD (HL),$0D ; insert carriage return at last new location.
1 LD (HL),$0D ; insert carriage return
1 LD (HL),$0D ; insert a carriage return at end.
1 LD (HL),$0D ; initially just has a carriage return
1 LD (HL),$05 ; maintain interrupt counter at 5.
1 LD (HL),$05 ; and initialize counter to 5
1 LD (HL),$01 ; load first location with digit 1.
1 LD (HL),$00 ; presume numeric and insert a zero
1 LD (HL),$00 ; make location zero
1 LD (HL),$00 ; last byte always zero for integers.
1 LD (HL),$00 ; first byte zero shows integer not exponent
1 LD (HL),$00 ; else make MODE zero - KLC mode
1 LD (HL),$00 ; clear inverse, over, ink/paper 9
1 LD (HL),$00 ; blank the first byte.
1 LD (HL),$00 ;
1 LD (DE),A ; update screen/printer
1 LD (DE),A ; the character is inserted.
1 LD (DE),A ; store each byte of first
1 LD (DE),A ; start is addressed by DE, so insert code
1 LD (DE),A ; put the key in workspace
1 LD (DE),A ; place zero there - now the null string.
1 LD (DE),A ; place zero in high byte of length.
1 LD (DE),A ; place quote in first new location at DE.
1 LD (DE),A ; place in destination.
1 LD (DE),A ; else load zero to destination
1 LD (DE),A ; and store in workspace
1 LD (DE),A ; and overwrite that in edit line.
1 LD (DE),A ; and load to edit line.
1 LD (DE),A ; and load into first destination byte.
1 LD (BC),A ; load memory location with A.
1 LD ($5CB4),HL ; set P-RAMT to the highest working RAM
1 LD ($5CB4),BC ; insert P-RAMT.
1 LD ($5CB2),HL ; update system variable RAMTOP.
1 LD ($5CAC),A ; MEM-5-1
1 LD ($5CA1),A ; MEM-3-1
1 LD ($5C91),A ; and save in P_FLAG.
1 LD ($5C91),A ; and restore system variable P_FLAG
1 LD ($5C8F),HL ; resave ATTR_T and MASK-T
1 LD ($5C8F),HL ; and update system variables.
1 LD ($5C8F),HL ; and restore system variables ATTR_T/MASK_T
1 LD ($5C8F),HL ; and reset ATTR_T, MASK-T as 'scroll?' has
1 LD ($5C8F),A ; set ATTR_T temporary colour attributes.
1 LD ($5C8D),HL ; and store in ATTR_P and MASK_P
1 LD ($5C8D),A ; set ATTR_P permanent colour attributes.
1 LD ($5C8C),A ; update SCR_CT system variable.
1 LD ($5C8C),A ; and place result in SCR_CT - scroll count.
1 LD ($5C8C),A ; SCR_CT scroll count
1 LD ($5C88),BC ; Update S_POSN - line/column upper screen
1 LD ($5C86),HL ; Update DFCCL lower screen memory address
1 LD ($5C84),HL ; Update DF_CC - upper display file address
1 LD ($5C82),HL ; and overwrite ECHO_E
1 LD ($5C82),BC ; Update ECHO_E line/column input buffer
1 LD ($5C80),HL ; Update PR_CC - full printer buffer memory
1 LD ($5C7D),HL ; Update the COORDS system variable.
1 LD ($5C7D),HL ; Set system variable COORDS to 0,0.
1 LD ($5C7B),HL ; make UDG system variable address the first
1 LD ($5C7B),HL ; insert UDG.
1 LD ($5C78),HL ; Place back in FRAMES1.
1 LD ($5C76),BC ; store in SEED for next starting point.
1 LD ($5C74),HL ; save pointer in system variable T_ADDR
1 LD ($5C74),A ; and put back in T_ADDR as 0,1,2, or 3
1 LD ($5C6C),DE ; update S_TOP.
1 LD ($5C6A),A ; update FLAGS2
1 LD ($5C68),HL ; is restored to system variable MEM.
1 LD ($5C68),HL ; and set MEM to point to three 5-byte values
1 LD ($5C68),HL ; The system variable MEM is made to point to
1 LD ($5C67),A ; and store value in system variable BREG.
1 LD ($5C65),HL ; use it to set STKEND system variable.
1 LD ($5C65),HL ; update system variable STKEND.
1 LD ($5C65),HL ; update STKEND as we are taking number.
1 LD ($5C65),HL ; set new STKEND.
1 LD ($5C65),HL ; set STKEND to the end of the empty stack.
1 LD ($5C65),HL ; set STKEND 'removing' value from stack.
1 LD ($5C65),HL ; and place in STKEND.
1 LD ($5C65),HL ; STKEND
1 LD ($5C65),DE ; Set STKEND to next free location.
1 LD ($5C63),HL ; set STKBOT - bottom of the empty stack.
1 LD ($5C63),HL ; and place in STKBOT
1 LD ($5C61),HL ; start of WORKSP
1 LD ($5C61),HL ; set WORKSP - empty workspace.
1 LD ($5C61),BC ; system variable WORKSP was perhaps
1 LD ($5C5F),IX ; save header pointer in X_PTR.
1 LD ($5C5F),IX ; place the IX header pointer in X_PTR
1 LD ($5C5F),HL ; store pointer in X_PTR
1 LD ($5C5F),HL ; save in X_PTR while input is assigned.
1 LD ($5C5F),HL ; save character position in X_PTR.
1 LD ($5C5F),HL ; preserve workspace pointer in dynamic X_PTR
1 LD ($5C5F),HL ; Copy it to the error pointer X_PTR.
1 LD ($5C5D),HL ; update the CH_ADD system variable.
1 LD ($5C5D),HL ; update system variable CH_ADD
1 LD ($5C5D),HL ; to set CH_ADD up for slicing routine
1 LD ($5C5D),HL ; system variable CH_ADD is set to first
1 LD ($5C5D),HL ; store in the system variable CH_ADD.
1 LD ($5C5D),HL ; set CH_ADD to this
1 LD ($5C5D),HL ; set CH_ADD to the start of the string again.
1 LD ($5C5D),HL ; set CH_ADD to first character
1 LD ($5C5D),HL ; save in CH_ADD
1 LD ($5C5D),HL ; put restored value back in CH_ADD
1 LD ($5C5D),HL ; initialize CH_ADD to this value.
1 LD ($5C5D),HL ; and update CH_ADD with character address.
1 LD ($5C5D),HL ; and reset the system variable CH_ADD.
1 LD ($5C5D),DE ; save in CH_ADD
1 LD ($5C5D),DE ; load CH_ADD with start DE in workspace.
1 LD ($5C5B),HL ; update K_CUR to address start of BASIC.
1 LD ($5C5B),HL ; set system variable K_CUR to new location.
1 LD ($5C5B),HL ; set K_CUR to start of empty area
1 LD ($5C5B),HL ; make K_CUR keyboard cursor point there.
1 LD ($5C5B),DE ; and update K_CUR system variable.
1 LD ($5C59),HL ; Set E_LINE, where the edit line
1 LD ($5C57),HL ; update system variable DATADD.
1 LD ($5C57),HL ; store back in DATADD
1 LD ($5C57),HL ; Set DATADD to location before program area.
1 LD ($5C55),BC ; update NXTLIN
1 LD ($5C53),HL ; and put back in PROG as it may have been
1 LD ($5C53),HL ; Set PROG the location where BASIC starts.
1 LD ($5C53),DE ; set PROG to original value.
1 LD ($5C4F),HL ; Set the CHANS system variable.
1 LD ($5C4D),HL ; save pointer in DEST.
1 LD ($5C4D),HL ; and DEST of assigned string.
1 LD ($5C4B),HL ; set system variable VARS
1 LD ($5C4B),HL ; Set VARS to same location with a
1 LD ($5C49),HL ; update E_PPC to new line number.
1 LD ($5C48),A ; set BORDCR the border colour/lower screen
1 LD ($5C47),A ; set statement number SUBPPC to zero.
1 LD ($5C45),HL ; is set/reset as line number in PPC.
1 LD ($5C45),DE ; set system variable PPC.
1 LD ($5C44),A ; set system variable NSPPC
1 LD ($5C42),HL ; set system variable to line number NEWPPC
1 LD ($5C42),HL ; and store it in NEWPPC
1 LD ($5C42),BC ; set system variable NEWPPC.
1 LD ($5C3D),SP ; set ERR_SP to point to IN-VAR-1 on stack.
1 LD ($5C3D),SP ; make system variable ERR_SP point to it.
1 LD ($5C3D),SP ; make ERR_SP point to location.
1 LD ($5C3D),SP ; make ERR_SP point to it.
1 LD ($5C3D),SP ; and ERR_SP made to point to it.
1 LD ($5C3D),SP ; adjust ERR_SP to point to new stack pointer
1 LD ($5C3D),HL ; update the system variable ERR_SP
1 LD ($5C3D),HL ; set ERR_SP to point to it.
1 LD ($5C3D),HL ; is restored to ERR_SP system variable
1 LD ($5C3D),HL ; ERR_SP is where the error pointer is
1 LD ($5C3A),A ; set ERR_NR to 'OK' - 1.
1 LD ($5C38),DE ; insert RASP/PIP.
1 LD ($5C38),BC ; the PIP and RASP system variables.
1 LD ($5C36),HL ; character set, CHARS - as no printing yet.
1 LD ($5C16),HL ; ensure STRMS-00 is keyboard.
1 LD ($5C0F),A ; store first operand in TVDATA-hi
1 LD ($5C0B),HL ; set DEFADD to point to this argument list
1 LD ($5C0B),HL ; blank DEFADD to signal that no defined
1 LD ($5C0B),HL ; and re-insert into DEFADD system variable.
1 LD ($5C09),HL ; loaded to REPDEL and REPPER.
1 LD D,$80 ;
1 LD C,A ;
1 JR Z,<A href="#L3671">L3671</a> ; skip to STK-CODE with zero if the null string.
1 JR Z,<A href="#L35BF">L35BF</a> ; skip forward to STK-PNTRS if so as complete.
1 JR Z,<A href="#L35B7">L35B7</a> ; to OTHER-STR if null string
1 JR Z,<A href="#L3585">L3585</a> ; forward to FRST-LESS if length is zero.
1 JR Z,<A href="#L3572">L3572</a> ; forward to BOTH-NULL if first string is also
1 JR Z,<A href="#L3483">L3483</a> ; forward to INT-CASE if a small integer
1 JR Z,<A href="#L32BD">L32BD</a> ; forward to RS-STORE if value is zero.
1 JR Z,<A href="#L3290">L3290</a> ; to IX-END
1 JR Z,<A href="#L3283">L3283</a> ; to BITS-ZERO
1 JR Z,<A href="#L3252">L3252</a> ; to T-NUMERIC
1 JR Z,<A href="#L31E2">L31E2</a> ; to DIV-START
1 JR Z,<A href="#L31AD">L31AD</a> ; to REPORT-6
1 JR Z,<A href="#L315E">L315E</a> ; to SKIP-ZERO
1 JR Z,<A href="#L3159">L3159</a> ; to NEAR-ZERO
1 JR Z,<A href="#L30A5">L30A5</a> ; to GO-NC-MLT
1 JR Z,<A href="#L309F">L309F</a> ; to ADD-REP-6
1 JR Z,<A href="#L2F59">L2F59</a> ; forward to PF-OUT-DT if so
1 JR Z,<A href="#L2F25">L2F25</a> ; skip to PF-R-BACK if ZERO?
1 JR Z,<A href="#L2EB8">L2EB8</a> ; skip to PF-ALL-9 if so to deal with the
1 JR Z,<A href="#L2E24">L2E24</a> ; forward if so to PF-SMALL
1 JR Z,<A href="#L2DE1">L2DE1</a> ; forward FP-A-END if zero
1 JR Z,<A href="#L2DAD">L2DAD</a> ; forward to FP-DELETE if an integer
1 JR Z,<A href="#L2D18">L2D18</a> ; forward to E-FP-JUMP if exponent positive
1 JR Z,<A href="#L2CFE">L2CFE</a> ; to SIGN-DONE
1 JR Z,<A href="#L2CF2">L2CF2</a> ; to SIGN-FLAG if so
1 JR Z,<A href="#L2CCB">L2CCB</a> ; skip to DECIMAL if so.
1 JR Z,<A href="#L2C7C">L2C7C</a> ; skip to DIM-CLEAR if numeric
1 JR Z,<A href="#L2C2E">L2C2E</a> ; loop back to D-NO-LOOP until all dimensions
1 JR Z,<A href="#L2BA3">L2BA3</a> ; forward to L-IN-W/S if so
1 JR Z,<A href="#L2B72">L2B72</a> ; skip forward to L-DELETE$ -*->
1 JR Z,<A href="#L2B66">L2B66</a> ; forward to L-EXISTS if not.
1 JR Z,<A href="#L2B4F">L2B4F</a> ; forward to L-SINGLE if it was just
1 JR Z,<A href="#L2B0C">L2B0C</a> ; back to L-NO-SP is so.
1 JR Z,<A href="#L2AEB">L2AEB</a> ; forward to I-RESTORE if checking syntax so
1 JR Z,<A href="#L2AE8">L2AE8</a> ; forward to I-CARRY if zero.
1 JR Z,<A href="#L2AAD">L2AAD</a> ; forward to SL-STORE to store entire string.
1 JR Z,<A href="#L2A94">L2A94</a> ; to SL-DEFINE using length as end point.
1 JR Z,<A href="#L2A81">L2A81</a> ; to SL-SECOND to evaluate second parameter.
1 JR Z,<A href="#L2A81">L2A81</a> ; to SL-SECOND to evaluate second parameter
1 JR Z,<A href="#L2A48">L2A48</a> ; forward to SV-DIM to consider further slice
1 JR Z,<A href="#L2A48">L2A48</a> ; forward to SV-DIM to consider a separate
1 JR Z,<A href="#L2A48">L2A48</a> ; forward to SV-DIM if so
1 JR Z,<A href="#L2A45">L2A45</a> ; loop back if so to SV-SLICE
1 JR Z,<A href="#L2A22">L2A22</a> ; skip to SV-NUMBER if so
1 JR Z,<A href="#L2A20">L2A20</a> ; forward to REPORT-3 if not
1 JR Z,<A href="#L29EA">L29EA</a> ; forward to SV-LOOP if so
1 JR Z,<A href="#L29E0">L29E0</a> ; back to SV-CH-ADD to consider a slice.
1 JR Z,<A href="#L29C0">L29C0</a> ; forward to SV-PTR with numeric arrays
1 JR Z,<A href="#L29A1">L29A1</a> ; back to SV-SIMPLE$ if result is zero as has
1 JR Z,<A href="#L2981">L2981</a> ; forward to SFA-MATCH with a match.
1 JR Z,<A href="#L296B">L296B</a> ; forward to SFA-CP-VR if so.
1 JR Z,<A href="#L2943">L2943</a> ; forward to V-PASS
1 JR Z,<A href="#L2932">L2932</a> ; to V-80-BYTE if zero as must be 10000000
1 JR Z,<A href="#L2913">L2913</a> ; back to V-SPACES until non-space
1 JR Z,<A href="#L2912">L2912</a> ; loop back to V-MATCHES if a match on an
1 JR Z,<A href="#L28EF">L28EF</a> ; forward to V-RUN/SYN if so.
1 JR Z,<A href="#L28EF">L28EF</a> ; forward to V-RUN/SYN if a defined function
1 JR Z,<A href="#L28DE">L28DE</a> ; forward to V-STR-VAR
1 JR Z,<A href="#L288D">L288D</a> ; forward to SF-VALUE if so.
1 JR Z,<A href="#L2885">L2885</a> ; forward to SF-R-BR-2 if so.
1 JR Z,<A href="#L2885">L2885</a> ; forward to SF-R-BR-2 if no arguments.
1 JR Z,<A href="#L2852">L2852</a> ; forward to SF-ARG-VL if numeric.
1 JR Z,<A href="#L2831">L2831</a> ; forward to SF-VALUES with a match.
1 JR Z,<A href="#L27F4">L27F4</a> ; forward to SF-SYN-EN if string function.
1 JR Z,<A href="#L27E9">L27E9</a> ; forward to SF-FLAG-6 if no arguments.
1 JR Z,<A href="#L2790">L2790</a> ; forward to S-NEXT if so
1 JR Z,<A href="#L275B">L275B</a> ; forward to S-SYNTEST if checking syntax.
1 JR Z,<A href="#L270D">L270D</a> ; forward to S-PUSH-PO if so
1 JR Z,<A href="#L2665">L2665</a> ; forward to S-INK$-EN if so
1 JR Z,<A href="#L2630">L2630</a> ; to S-PI-END if checking syntax.
1 JR Z,<A href="#L2625">L2625</a> ; forward to S-RND-END if checking syntax.
1 JR Z,<A href="#L2625">L2625</a> ; forward if so to S-RND-END
1 JR Z,<A href="#L25D9">L25D9</a> ; forward to S-Q-PRMS if checking syntax.
1 JR Z,<A href="#L25CB">L25CB</a> ; to S-Q-COPY if so including just one of the
1 JR Z,<A href="#L25BE">L25BE</a> ; back to S-Q-AGAIN if two quotes WERE
1 JR Z,<A href="#L255A">L255A</a> ; forward to S-SC-MTCH if they match
1 JR Z,<A href="#L24F9">L24F9</a> ; to REPORT-Bc
1 JR Z,<A href="#L245F">L245F</a> ; forward, if zero (not possible), to ARC-END
1 JR Z,<A href="#L238D">L238D</a> ; forward, if so, to DR-3-PRMS
1 JR Z,<A href="#L2287">L2287</a> ; forward to CO-TEMP-E if 8
1 JR Z,<A href="#L2273">L2273</a> ; forward to CO-TEMP-C with FLASH and BRIGHT.
1 JR Z,<A href="#L2257">L2257</a> ; forward to CO-TEMP-A with INK/PAPER 8
1 JR Z,<A href="#L2257">L2257</a> ; forward to CO-TEMP-A if black and
1 JR Z,<A href="#L2234">L2234</a> ; forward to CO-TEMP-7 with INK and PAPER.
1 JR Z,<A href="#L21E1">L21E1</a> ; back to CO-TEMP-1 for more.
1 JR Z,<A href="#L21E1">L21E1</a> ; back if so to CO-TEMP-1
1 JR Z,<A href="#L21D0">L21D0</a> ; forward to IN-STOP if so.
1 JR Z,<A href="#L2148">L2148</a> ; forward to IN-VAR-2 if not using the
1 JR Z,<A href="#L20C1">L20C1</a> ; back to IN-ITEM-1 until no more in a
1 JR Z,<A href="#L2096">L2096</a> ; forward to INPUT-1 if checking syntax.
1 JR Z,<A href="#L2067">L2067</a> ; forward to PR-POSN-3 if so.
1 JR Z,<A href="#L2067">L2067</a> ; forward to PR-POSN-3 if checking syntax.
1 JR Z,<A href="#L1FF2">L1FF2</a> ; to PRINT-4 if not e.g. just 'PRINT :'
1 JR Z,<A href="#L1FE5">L1FE5</a> ; to PRINT-3 if consecutive positioners
1 JR Z,<A href="#L1FE5">L1FE5</a> ; loop back to PRINT-3 if so
1 JR Z,<A href="#L1FA6">L1FA6</a> ; to DEF-FN-6 if null argument
1 JR Z,<A href="#L1F6A">L1F6A</a> ; forward to DEF-FN-1 if parsing
1 JR Z,<A href="#L1F4F">L1F4F</a> ; forward to PAUSE-END if so.
1 JR Z,<A href="#L1F3D">L1F3D</a> ; back to PAUSE-1 if not.
1 JR Z,<A href="#L1F36">L1F36</a> ; forward to REPORT-7 with a match.
1 JR Z,<A href="#L1E8E">L1E8E</a> ; forward to TWO-P-1 if positive
1 JR Z,<A href="#L1E1E">L1E1E</a> ; forward to READ-2 if checking syntax
1 JR Z,<A href="#L1E0A">L1E0A</a> ; forward to READ-1 if so.
1 JR Z,<A href="#L1DEC">L1DEC</a> ; back to READ-3 if so
1 JR Z,<A href="#L1DD8">L1DD8</a> ; forward to REPORT-1 if not
1 JR Z,<A href="#L1DA3">L1DA3</a> ; forward to LOOK-P-2 if so.
1 JR Z,<A href="#L1D7C">L1D7C</a> ; forward to F-FOUND if it matches.
1 JR Z,<A href="#L1D00">L1D00</a> ; forward to IF-1 if checking syntax
1 JR Z,<A href="#L1CE6">L1CE6</a> ; forward to USE-ZERO if so
1 JR Z,<A href="#L1CD6">L1CD6</a> ; forward to CL-09-1 if checking syntax.
1 JR Z,<A href="#L1BF4">L1BF4</a> ; forward to STMT-NEXT if address found.
1 JR Z,<A href="#L1BBF">L1BBF</a> ; forward to LINE-USE if was a program line
1 JR Z,<A href="#L1BBF">L1BBF</a> ; forward to LINE-USE if line matched.
1 JR Z,<A href="#L1BB3">L1BB3</a> ; forward to LINE-END if so.
1 JR Z,<A href="#L1BB3">L1BB3</a> ; back to LINE-END if so.
1 JR Z,<A href="#L1B9E">L1B9E</a> ; forward to LINE-NEW if a jump is to be
1 JR Z,<A href="#L1B28">L1B28</a> ; back to STMT-LOOP if so.
1 JR Z,<A href="#L19D6">L19D6</a> ; forward to NEXT-O-4 to compute length.
1 JR Z,<A href="#L19AD">L19AD</a> ; to EACH-S-5
1 JR Z,<A href="#L1990">L1990</a> ; to EACH-S-1 if not
1 JR Z,<A href="#L196C">L196C</a> ; to OUT-CH-3 to output if so.
1 JR Z,<A href="#L196C">L196C</a> ; to OUT-CH-3 if ':' is outside quoted text.
1 JR Z,<A href="#L1925">L1925</a> ; back to OUT-SP-2 if it is zero.
1 JR Z,<A href="#L1909">L1909</a> ; forward to OUT-C-2 if so to print.
1 JR Z,<A href="#L1909">L1909</a> ; forward to OUT-C-2 if not set to print.
1 JR Z,<A href="#L18F3">L18F3</a> ; to OUT-C-1 if still zero ('KLC').
1 JR Z,<A href="#L18B4">L18B4</a> ; to OUT-LINE6, if so, as line is finished.
1 JR Z,<A href="#L1894">L1894</a> ; forward to OUT-LINE4 if not.
1 JR Z,<A href="#L1881">L1881</a> ; to OUT-LINE3 if zero.
1 JR Z,<A href="#L1865">L1865</a> ; to OUT-LINE1 if matched or line after.
1 JR Z,<A href="#L1835">L1835</a> ; back to LIST-ALL-2 if not
1 JR Z,<A href="#L1814">L1814</a> ; skip to LIST-2 if so.
1 JR Z,<A href="#L17ED">L17ED</a> ; to AUTO-L-4 if line exists.
1 JR Z,<A href="#L1756">L1756</a> ; skip forward to OPEN-1 if so.
1 JR Z,<A href="#L15DE">L15DE</a> ; back to WAIT-KEY1 if no key is pressed
1 JR Z,<A href="#L15AB">L15AB</a> ; forward to MAIN-ADD2 is so.
1 JR Z,<A href="#L1386">L1386</a> ; forward to MAIN-9 if no error.
1 JR Z,<A href="#L1384">L1384</a> ; skip forward to MAIN-8, if not, as set-up
1 JR Z,<A href="#L1373">L1373</a> ; forward to MAIN-6 if so
1 JR Z,<A href="#L1303">L1303</a> ; forward to MAIN-4 if not.
1 JR Z,<A href="#L12A2">L12A2</a> ; back to MAIN-EXEC if so for an automatic
1 JR Z,<A href="#L1219">L1219</a> ; forward to RAM-SET if we did.
1 JR Z,<A href="#L11EF">L11EF</a> ; forward to RAM-DONE if faulty.
1 JR Z,<A href="#L11E2">L11E2</a> ; back to RAM-READ if zero flag was set.
1 JR Z,<A href="#L1026">L1026</a> ; back to ED-END if not.
1 JR Z,<A href="#L1024">L1024</a> ; back to ED-ENTER if not to treat as if
1 JR Z,<A href="#L0E80">L0E80</a> ; skip to CL-LINE-3 if not.
1 JR Z,<A href="#L0DEE">L0DEE</a> ; skip to CL-SET-1 if handling upper part
1 JR Z,<A href="#L0D5B">L0D5B</a> ; skip to TEMPS-1 if not
1 JR Z,<A href="#L0D00">L0D00</a> ; forward to REPORT-D if so else scroll.
1 JR Z,<A href="#L0CD2">L0CD2</a> ; to PO-SCR-3 if zero and scrolling required.
1 JR Z,<A href="#L0C88">L0C88</a> ; forward to PO-SCR-2 if not.
1 JR Z,<A href="#L0C44">L0C44</a> ; back to PO-STEP if not inverted.
1 JR Z,<A href="#L0C35">L0C35</a> ; forward to PO-TR-SP to consider trailing
1 JR Z,<A href="#L0C08">L0C08</a> ; skip to PO-ATTR-2 if not
1 JR Z,<A href="#L0BFA">L0BFA</a> ; skip to PO-ATTR-1 if not.
1 JR Z,<A href="#L0BB6">L0BB6</a> ; to PR-ALL-3 if screen
1 JR Z,<A href="#L0B93">L0B93</a> ; to PR-ALL-1 if not
1 JR Z,<A href="#L0923">L0923</a> ; forward if so to ME-VAR-L2 to add
1 JR Z,<A href="#L0909">L0909</a> ; forward to ME-OLD-V2 if a match to replace.
1 JR Z,<A href="#L0873">L0873</a> ; forward if so to LD-PROG
1 JR Z,<A href="#L084C">L084C</a> ; forward if so to LD-DATA-1
1 JR Z,<A href="#L07E9">L07E9</a> ; forward to VR-CONT-1 if lengths match.
1 JR Z,<A href="#L07E9">L07E9</a> ; forward to VR-CONT-1 if length unspecified
1 JR Z,<A href="#L07CB">L07CB</a> ; forward to VR-CONTRL if it is CODE.
1 JR Z,<A href="#L0723">L0723</a> ; forward to SA-LINE-1 if so.
1 JR Z,<A href="#L06F5">L06F5</a> ; forward if so to SA-CODE-3
1 JR Z,<A href="#L0692">L0692</a> ; forward to SA-DATA-1 if checking syntax.
1 JR Z,<A href="#L068F">L068F</a> ; forward to SA-V-TYPE if numeric.
1 JR Z,<A href="#L0685">L0685</a> ; forward to SA-V-NEW with LOAD DATA.
1 JR Z,<A href="#L0652">L0652</a> ; forward to SA-DATA if so using the 255
1 JR Z,<A href="#L0652">L0652</a> ; forward to SA-DATA if checking syntax.
1 JR Z,<A href="#L0621">L0621</a> ; forward to SA-SPACE if so.
1 JR Z,<A href="#L05ED">L05ED</a> ; back to LD-SAMPLE if no edge.
1 JR Z,<A href="#L050E">L050E</a> ; forward to SA-PARITY if zero.
1 JR Z,<A href="#L04D0">L04D0</a> ; skip to SA-FLAG if a header is being saved.
1 JR Z,<A href="#L03F6">L03F6</a> ;(12/7); go to BE-END
1 JR Z,<A href="#L03B2">L03B2</a> ; forward to K-@-CHAR if so
1 JR Z,<A href="#L0364">L0364</a> ; skip to K-TOKENS if so
1 JR Z,<A href="#L034A">L034A</a> ; to K-LOOK-UP if sym-shift
1 JR Z,<A href="#L034A">L034A</a> ; forward to K-LOOK-UP if neither shift.
1 JR Z,<A href="#L034A">L034A</a> ; back to K-LOOK-UP with symbol-shift
1 JR Z,<A href="#L034A">L034A</a> ; back to K-LOOK-UP - changed to $0F, GRAPHICS.
1 JR Z,<A href="#L034A">L034A</a> ; back to K-LOOK-UP - changed to $0C, delete.
1 JR Z,<A href="#L0341">L0341</a> ; to K-E-LET if was 1 for extended letters.
1 JR Z,<A href="#L02AB">L02AB</a> ; forward to KEY-DONE if zero and therefore
1 JR NZ,<A href="#L3705">L3705</a> ; to N-NEGTV
1 JR NZ,<A href="#L3687">L3687</a> ; to JUMP-2 if not zero
1 JR NZ,<A href="#L3686">L3686</a> ; Back to JUMP if true (1).
1 JR NZ,<A href="#L360C">L360C</a> ; forward to V-RPORT-C if not
1 JR NZ,<A href="#L35DC">L35DC</a> ; forward to REPORT-Bd if negative
1 JR NZ,<A href="#L3575">L3575</a> ; forward to SEC-PLUS if second not null.
1 JR NZ,<A href="#L356B">L356B</a> ; back to SECND-LOW and then STR-TEST
1 JR NZ,<A href="#L3559">L3559</a> ; forward to STRINGS if so.
1 JR NZ,<A href="#L3543">L3543</a> ; skip to EX-OR-NOT with these.
1 JR NZ,<A href="#L34E7">L34E7</a> ; to REPORT-A if not a single character.
1 JR NZ,<A href="#L33DE">L33DE</a> ; forward to FORM-EXP if it was possible to
1 JR NZ,<A href="#L32B1">L32B1</a> ; skip to RS-NRMLSE if not.
1 JR NZ,<A href="#L326C">L326C</a> ; to T-EXPNENT
1 JR NZ,<A href="#L323F">L323F</a> ; to T-SMALL
1 JR NZ,<A href="#L3233">L3233</a> ; to T-FIRST
1 JR NZ,<A href="#L31AD">L31AD</a> ; to REPORT-6
1 JR NZ,<A href="#L3195">L3195</a> ; to OFLOW-CLR
1 JR NZ,<A href="#L3186">L3186</a> ; to NORML-NOW
1 JR NZ,<A href="#L3151">L3151</a> ; to OFLW2-CLR
1 JR NZ,<A href="#L313B">L313B</a> ; to MAKE-EXPT
1 JR NZ,<A href="#L30F0">L30F0</a> ; to MULT-LONG
1 JR NZ,<A href="#L30EA">L30EA</a> ; to MULT-RSLT
1 JR NZ,<A href="#L303E">L303E</a> ; forward to FULL-ADDN if at least one was
1 JR NZ,<A href="#L303C">L303C</a> ; forward to ADDN-OFLW if not
1 JR NZ,<A href="#L300D">L300D</a> ; to ALL-ADDED
1 JR NZ,<A href="#L2EB3">L2EB3</a> ; skip forward to PF-TEST-2 if flag still $FF
1 JR NZ,<A href="#L2EA9">L2EA9</a> ; to PF-INSERT if non-zero value picked up.
1 JR NZ,<A href="#L2E8A">L2E8A</a> ; back to PF-BYTES until the ten nibbles rolled
1 JR NZ,<A href="#L2E56">L2E56</a> ; forward to PF-LARGE if a large integer
1 JR NZ,<A href="#L2E1E">L2E1E</a> ; forward to PF-SAVE if 16-bit integer.
1 JR NZ,<A href="#L2CFF">L2CFF</a> ; to ST-E-PART as no sign
1 JR NZ,<A href="#L2CEB">L2CEB</a> ; to E-FORMAT if not to consider that format
1 JR NZ,<A href="#L2CB8">L2CB8</a> ; to NOT-BIN if not
1 JR NZ,<A href="#L2CB3">L2CB3</a> ; forward to BIN-END if result not zero
1 JR NZ,<A href="#L2C7F">L2C7F</a> ; back to DIM-SIZES until all done.
1 JR NZ,<A href="#L2C2D">L2C2D</a> ; forward to D-SIZE if so.
1 JR NZ,<A href="#L2C15">L2C15</a> ; forward to D-RUN in runtime.
1 JR NZ,<A href="#L2C05">L2C05</a> ; to D-RPORT-C with anything else
1 JR NZ,<A href="#L2BAF">L2BAF</a> ; forward to L-ADD$ if so.
1 JR NZ,<A href="#L2A7A">L2A7A</a> ; to SL-RPT-C if not
1 JR NZ,<A href="#L2A2C">L2A2C</a> ; forward to SV-ELEM$ if so.
1 JR NZ,<A href="#L2A20">L2A20</a> ; to REPORT-3 with anything else
1 JR NZ,<A href="#L2A20">L2A20</a> ; to REPORT-3 if not
1 JR NZ,<A href="#L2A12">L2A12</a> ; to SV-RPT-C with anything else
1 JR NZ,<A href="#L2A12">L2A12</a> ; forward to SV-RPT-C if not
1 JR NZ,<A href="#L29FB">L29FB</a> ; forward to SV-MULT if not an array of
1 JR NZ,<A href="#L29E7">L29E7</a> ; forward to SV-COUNT if so.
1 JR NZ,<A href="#L29D8">L29D8</a> ; forward to SV-CLOSE if so
1 JR NZ,<A href="#L29AE">L29AE</a> ; forward to SV-ARRAYS otherwise
1 JR NZ,<A href="#L2991">L2991</a> ; to SFA-END if so as will be stacked
1 JR NZ,<A href="#L292A">L292A</a> ; forward to V-NEXT if no match.
1 JR NZ,<A href="#L2929">L2929</a> ; forward to V-GET-PTR if no match
1 JR NZ,<A href="#L28FD">L28FD</a> ; to V-RUN to look for the variable in runtime
1 JR NZ,<A href="#L288B">L288B</a> ; forward to REPORT-Q if type mismatch.
1 JR NZ,<A href="#L288B">L288B</a> ; forward to REPORT-Q if not
1 JR NZ,<A href="#L2825">L2825</a> ; forward to SF-NOT-FD if no match.
1 JR NZ,<A href="#L2802">L2802</a> ; forward if not '$' to SF-ARGMT1
1 JR NZ,<A href="#L27F7">L27F7</a> ; forward to SF-RUN in runtime
1 JR NZ,<A href="#L27E6">L27E6</a> ; forward to SF-RPRT-C if not
1 JR NZ,<A href="#L27E4">L27E4</a> ; forward if not to SF-BRKT-2 to test bracket
1 JR NZ,<A href="#L27D0">L27D0</a> ; forward to SF-BRKT-1 with numeric function
1 JR NZ,<A href="#L2790">L2790</a> ; forward to S-NEXT if numeric result
1 JR NZ,<A href="#L2788">L2788</a> ; forward to S-NOT-AND if not.
1 JR NZ,<A href="#L2770">L2770</a> ; forward to S-LOOPEND if numeric
1 JR NZ,<A href="#L274C">L274C</a> ; forward to S-STK-LST if numeric
1 JR NZ,<A href="#L274C">L274C</a> ; forward to S-STK-LST if not
1 JR NZ,<A href="#L2734">L2734</a> ; forward, if numeric, to S-LOOP
1 JR NZ,<A href="#L2723">L2723</a> ; forward, if not, to S-OPERTR
1 JR NZ,<A href="#L26B6">L26B6</a> ; to S-SD-SKIP until a match
1 JR NZ,<A href="#L26B5">L26B5</a> ; to S-STK-DEC in runtime
1 JR NZ,<A href="#L2660">L2660</a> ; to S-IK$-STK to store empty string if
1 JR NZ,<A href="#L25D9">L25D9</a> ; forward to S-Q-PRMS if
1 JR NZ,<A href="#L25CB">L25CB</a> ; back to S-Q-COPY to copy more if not
1 JR NZ,<A href="#L2573">L2573</a> ; forward to S-SCR-NXT if no match.
1 JR NZ,<A href="#L2573">L2573</a> ; forward to S-SCR-NXT if a mismatch
1 JR NZ,<A href="#L252D">L252D</a> ; forward to S-RPORT-C if not
1 JR NZ,<A href="#L250F">L250F</a> ; back to S-QUOTE-S if not for more.
1 JR NZ,<A href="#L2303">L2303</a> ; to PLOT-END if so.
1 JR NZ,<A href="#L22FD">L22FD</a> ; forward to PL-TST-IN if so.
1 JR NZ,<A href="#L22A6">L22A6</a> ; skip to BORDER-1 if so
1 JR NZ,<A href="#L227D">L227D</a> ; forward to CO-TEMP-D if flash
1 JR NZ,<A href="#L2228">L2228</a> ; forward to CO-TEMP-6 if OVER
1 JR NZ,<A href="#L219B">L219B</a> ; forward to IN-VAR-6 if INPUT LINE.
1 JR NZ,<A href="#L2174">L2174</a> ; forward to IN-VAR-5 if using another input
1 JR NZ,<A href="#L215E">L215E</a> ; forward to IN-VAR-3 if so as input will
1 JR NZ,<A href="#L211C">L211C</a> ; forward to IN-PR-2 if so as that is
1 JR NZ,<A href="#L211A">L211A</a> ; forward to IN-PR-1 if so
1 JR NZ,<A href="#L20ED">L20ED</a> ; forward to IN-ITEM-3 if not.
1 JR NZ,<A href="#L20D8">L20D8</a> ; forward to IN-ITEM-2 if not.
1 JR NZ,<A href="#L206E">L206E</a> ; to PR-POSN-4 if not.
1 JR NZ,<A href="#L2061">L2061</a> ; forward to PR-POSN-2 if anything else.
1 JR NZ,<A href="#L2024">L2024</a> ; to PR-ITEM-3 if not
1 JR NZ,<A href="#L200E">L200E</a> ; forward to PR-ITEM-2 if not.
1 JR NZ,<A href="#L1FBD">L1FBD</a> ; to DEF-FN-7 if not 'Nonsense...'
1 JR NZ,<A href="#L1FBD">L1FBD</a> ; to DEF-FN-7 if not
1 JR NZ,<A href="#L1FBD">L1FBD</a> ; to DEF-FN-7 'Nonsense in BASIC'
1 JR NZ,<A href="#L1FA6">L1FA6</a> ; to DEF-FN-6 if not
1 JR NZ,<A href="#L1F94">L1F94</a> ; forward to DEF-FN-5 if not.
1 JR NZ,<A href="#L1F7D">L1F7D</a> ; to DEF-FN-2 if not as numeric.
1 JR NZ,<A href="#L1F49">L1F49</a> ; skip forward to PAUSE-2 if not.
1 JR NZ,<A href="#L1EB7">L1EB7</a> ; skip to CLEAR-1 if not zero.
1 JR NZ,<A href="#L1E5A">L1E5A</a> ; forward to RAND-1 if not zero.
1 JR NZ,<A href="#L1E37">L1E37</a> ; forward to DATA-2 if in runtime
1 JR NZ,<A href="#L1D10">L1D10</a> ; to F-USE-1 if not to use 1 as default.
1 JR NZ,<A href="#L1C8A">L1C8A</a> ; to REPORT-C if not required separator.
1 JR NZ,<A href="#L1C8A">L1C8A</a> ; forward to REPORT-C if result not zero.
1 JR NZ,<A href="#L1C8A">L1C8A</a> ; forward to REPORT-C if not zero
1 JR NZ,<A href="#L1C82">L1C82</a> ; forward to EXPT-1NUM if not.
1 JR NZ,<A href="#L1C46">L1C46</a> ; to VAR-A-3 if numeric
1 JR NZ,<A href="#L1C46">L1C46</a> ; to VAR-A-3 if not assigning to an array
1 JR NZ,<A href="#L1BF4">L1BF4</a> ; forward to STMT-NEXT if a program line.
1 JR NZ,<A href="#L1BEC">L1BEC</a> ; forward to REPORT-N if not.
1 JR NZ,<A href="#L1A42">L1A42</a> ; forward to OUT-NUM-4 if so to print zero
1 JR NZ,<A href="#L19B1">L19B1</a> ; to EACH-S-6
1 JR NZ,<A href="#L19A5">L19A5</a> ; to EACH-S-4 if not
1 JR NZ,<A href="#L199A">L199A</a> ; forward to EACH-S-3 if not
1 JR NZ,<A href="#L1998">L1998</a> ; to EACH-S-2
1 JR NZ,<A href="#L1968">L1968</a> ; to OUT-CH-2 with others to set 'L' mode.
1 JR NZ,<A href="#L1968">L1968</a> ; to OUT-CH-2 if in input as no statements.
1 JR NZ,<A href="#L195A">L195A</a> ; to OUT-CH-1 if not statement separator
1 JR NZ,<A href="#L18A1">L18A1</a> ; forward to OUT-LINE5 if not.
1 JR NZ,<A href="#L1835">L1835</a> ; back to LIST-ALL-2 if upper screen not full.
1 JR NZ,<A href="#L181A">L181A</a> ; forward to LIST-3 if neither separator.
1 JR NZ,<A href="#L1767">L1767</a> ; skip forward to OPEN-3 with 1 character
1 JR NZ,<A href="#L1765">L1765</a> ; to REPORT-Fb 'Invalid file name' if not.
1 JR NZ,<A href="#L1725">L1725</a> ; back to REPORT-Ob if not.
1 JR NZ,<A href="#L16DB">L16DB</a> ; back to INDEXER-1 if no match.
1 JR NZ,<A href="#L1691">L1691</a> ; to LINE-NO-A if an end-marker.
1 JR NZ,<A href="#L166B">L166B</a> ; back to PTR-NEXT if more.
1 JR NZ,<A href="#L1610">L1610</a> ; forward to CHAN-OP-1 if open.
1 JR NZ,<A href="#L15DE">L15DE</a> ; forward to WAIT-KEY1 if so.
1 JR NZ,<A href="#L157D">L157D</a> ; forward if no existing line to MAIN-ADD1.
1 JR NZ,<A href="#L1376">L1376</a> ; forward to MAIN-7 if not
1 JR NZ,<A href="#L12CF">L12CF</a> ; forward, if correct, to MAIN-3.
1 JR NZ,<A href="#L11DC">L11DC</a> ; Back to RAM-FILL if not.
1 JR NZ,<A href="#L11A7">L11A7</a> ; back to REMOVE-FP until entire line done.
1 JR NZ,<A href="#L115E">L115E</a> ; forward to ED-SPACES if line has changed
1 JR NZ,<A href="#L1105">L1105</a> ; forward to KEY-DATA with INK 16d and
1 JR NZ,<A href="#L10F4">L10F4</a> ; forward to KEY-FLAG if it has changed.
1 JR NZ,<A href="#L1051">L1051</a> ; to ED-EDGE-2 if not
1 JR NZ,<A href="#L1051">L1051</a> ; forward to ED-EDGE-2 if not
1 JR NZ,<A href="#L1001">L1001</a> ; skip to ED-STOP if so
1 JR NZ,<A href="#L0F14">L0F14</a> ; back to COPY-L-3 until 256 bits done.
1 JR NZ,<A href="#L0EC9">L0EC9</a> ; forward to COPY-2 if not to continue loop.
1 JR NZ,<A href="#L0E4D">L0E4D</a> ; back to CL-LINE-2 if 16 or 8 to do
1 JR NZ,<A href="#L0E4A">L0E4A</a> ; back to CL-LINE-1 till all done.
1 JR NZ,<A href="#L0E19">L0E19</a> ; forward to CL-SCR-3 if partial scroll.
1 JR NZ,<A href="#L0E0D">L0E0D</a> ; back to CL-SCR-2 if not.
1 JR NZ,<A href="#L0E05">L0E05</a> ; back to CL-SCR-1 if all eight not done.
1 JR NZ,<A href="#L0DF4">L0DF4</a> ; forward to CL-SET-2 if so.
1 JR NZ,<A href="#L0D89">L0D89</a> ; loop back to CLS-2 until all 32 cells done.
1 JR NZ,<A href="#L0D65">L0D65</a> ; skip to TEMPS-2 if lower screen using A=0.
1 JR NZ,<A href="#L0D1C">L0D1C</a> ; back to PO-SCR-4A until done
1 JR NZ,<A href="#L0CD2">L0CD2</a> ; forward to PO-SCR-3 to scroll display if
1 JR NZ,<A href="#L0C44">L0C44</a> ; back to PO-STEP if not zero
1 JR NZ,<A href="#L0C08">L0C08</a> ; to PO-ATTR-2
1 JR NZ,<A href="#L0BFA">L0BFA</a> ; skip to PO-ATTR-1
1 JR NZ,<A href="#L0BB7">L0BB7</a> ; back to PR-ALL-4 for all 8 bytes
1 JR NZ,<A href="#L0B93">L0B93</a> ; but if not zero to PR-ALL-1
1 JR NZ,<A href="#L0B76">L0B76</a> ; to PO-CHAR-3 if not
1 JR NZ,<A href="#L0B4C">L0B4C</a> ; to PO-GR-3 until byte is stored 4 times
1 JR NZ,<A href="#L0B1D">L0B1D</a> ; Forward, if so, to PO-F-PR
1 JR NZ,<A href="#L0AFC">L0AFC</a> ; Forward, if so, to PO-ST-PR
1 JR NZ,<A href="#L0AF0">L0AF0</a> ; Forward, if so, to PO-ST-E
1 JR NZ,<A href="#L0AD0">L0AD0</a> ; to PO-SPACE until done
1 JR NZ,<A href="#L0AC2">L0AC2</a> ; to PO-TAB if not 22d i.e. 23d TAB.
1 JR NZ,<A href="#L0ABF">L0ABF</a> ; to PO-AT-SET as line can be ignored.
1 JR NZ,<A href="#L0A38">L0A38</a> ; to PO-BACK-2 if so, as we are unable to
1 JR NZ,<A href="#L0921">L0921</a> ; forward to ME-VAR-L1 if just one-character.
1 JR NZ,<A href="#L091E">L091E</a> ; forward to ME-OLD-V4 with a mismatch.
1 JR NZ,<A href="#L08F0">L08F0</a> ; forward to ME-VAR-LP if a variable or
1 JR NZ,<A href="#L08DF">L08DF</a> ; forward to ME-OLD-L1 if high bytes don't match
1 JR NZ,<A href="#L08AD">L08AD</a> ; forward to LD-PROG-1 if so with no autostart.
1 JR NZ,<A href="#L0819">L0819</a> ; forward if not to LD-CONT-1
1 JR NZ,<A href="#L0806">L0806</a> ; forward to REPORT-R if so
1 JR NZ,<A href="#L0800">L0800</a> ; skip to VR-CONT-3 if not
1 JR NZ,<A href="#L07F4">L07F4</a> ; forward to VR-CONT-2 if destination specified.
1 JR NZ,<A href="#L07AD">L07AD</a> ; forward to LD-CH-PR with mismatch
1 JR NZ,<A href="#L07A6">L07A6</a> ; forward to LD-NAME if not the wildcard.
1 JR NZ,<A href="#L078A">L078A</a> ; forward to LD-TYPE with mis-match.
1 JR NZ,<A href="#L0767">L0767</a> ; back to LD-LOOK-H if not
1 JR NZ,<A href="#L0716">L0716</a> ; forward if not to SA-LINE to consider an
1 JR NZ,<A href="#L06E1">L06E1</a> ; forward to SA-CODE-1 if there are parameters.
1 JR NZ,<A href="#L06C3">L06C3</a> ; forward to SA-CODE if not.
1 JR NZ,<A href="#L06A0">L06A0</a> ; forward to SA-SCR$ to consider SCREEN$ if
1 JR NZ,<A href="#L0672">L0672</a> ; back if not to SA-V-OLD to report
1 JR NZ,<A href="#L0644">L0644</a> ; forward to SA-NULL if not the SAVE command.
1 JR NZ,<A href="#L05E9">L05E9</a> ; loop back to LD-DELAY 22 times.
1 JR NZ,<A href="#L05B3">L05B3</a> ; forward to LD-FLAG if awaiting initial flag
1 JR NZ,<A href="#L05A9">L05A9</a> ; back to LD-LOOP
1 JR NZ,<A href="#L0580">L0580</a> ; back to LD-LEADER while more to do.
1 JR NZ,<A href="#L0574">L0574</a> ; back to LD-WAIT, if not zero, with zero in B.
1 JR NZ,<A href="#L0511">L0511</a> ; back to SA-BIT-2 if zero reset NZ (first pass)
1 JR NZ,<A href="#L04D8">L04D8</a> ; back to SA-LEADER until L is zero.
1 JR NZ,<A href="#L046C">L046C</a> ; to REPORT-B
1 JR NZ,<A href="#L03F2">L03F2</a> ;(12/7); to BE-AGAIN
1 JR NZ,<A href="#L03D6">L03D6</a> ;(12/7); high or low pulse of waveform
1 JR NZ,<A href="#L0389">L0389</a> ; forward to K-GRA-DGT if mode was 2.
1 JR NZ,<A href="#L034A">L034A</a> ; back to K-LOOK-UP if shift pressed.
1 JR NZ,<A href="#L032C">L032C</a> ; forward to K-MAIN if not
1 JR NZ,<A href="#L02F1">L02F1</a> ; forward to K-NEW if so.
1 JR NZ,<A href="#L02D1">L02D1</a> ; forward to K-CH-SET if so
1 JR NZ,<A href="#L02D1">L02D1</a> ; forward to K-CH-SET if not at end of count
1 JR NZ,<A href="#L02C6">L02C6</a> ; back to K-ST-LOOP to consider this 2nd set
1 JR NZ,<A href="#L029F">L029F</a> ; back to KEY-3KEYS if there were more
1 JR NZ,<A href="#L0070">L0070</a> ; skip to NO-RESET if NOT ZERO
1 JR NZ,<A href="#L0048">L0048</a> ; Forward, if not, to KEY-INT
1 JR NC,<A href="#L370E">L370E</a> ; to RSLT-ZERO
1 JR NC,<A href="#L370C">L370C</a> ; to RESULT-OK
1 JR NC,<A href="#L365F">L365F</a> ; forward to R-I-STORE if no key detected.
1 JR NC,<A href="#L354E">L354E</a> ; forward to NU-OR-STR with other 8 cases
1 JR NC,<A href="#L34E7">L34E7</a> ; to REPORT-A if originally higher
1 JR NC,<A href="#L34E7">L34E7</a> ; to REPORT-A if higher than 20.
1 JR NC,<A href="#L34E4">L34E4</a> ; forward to USR-STACK if no overflow.
1 JR NC,<A href="#L338C">L338C</a> ; to DOUBLE-A with unary operations
1 JR NC,<A href="#L32B2">L32B2</a> ; loop back to RSTK-LOOP
1 JR NC,<A href="#L3221">L3221</a> ; to T-GR-ZERO
1 JR NC,<A href="#L31F9">L31F9</a> ; to NO-RSTORE
1 JR NC,<A href="#L31AD">L31AD</a> ; to REPORT-6
1 JR NC,<A href="#L3195">L3195</a> ; to OFLOW-CLR
1 JR NC,<A href="#L30BC">L30BC</a> ; to HL-AGAIN to skip addition if no carry
1 JR NC,<A href="#L30A3">L30A3</a> ; to END-COMPL
1 JR NC,<A href="#L307C">L307C</a> ; to TEST-NEG
1 JR NC,<A href="#L3055">L3055</a> ; to SHIFT-LEN
1 JR NC,<A href="#L2FF9">L2FF9</a> ; to ADDEND-0
1 JR NC,<A href="#L2F2D">L2F2D</a> ; forward to PF-COUNT with 1 - 9.
1 JR NC,<A href="#L2D71">L2D71</a> ; forward to E-TST-END if no bit
1 JR NC,<A href="#L2D55">L2D55</a> ; to E-SAVE if positive.
1 JR NC,<A href="#L2B9B">L2B9B</a> ; forward if it fits to L-LENGTH.
1 JR NC,<A href="#L2B29">L2B29</a> ; forward to L-SPACES if so.
1 JR NC,<A href="#L2B1F">L2B1F</a> ; forward to L-TEST-CH if higher.
1 JR NC,<A href="#L294B">L294B</a> ; forward to V-END if not
1 JR NC,<A href="#L293E">L293E</a> ; forward to V-FOUND-1 with a full match.
1 JR NC,<A href="#L28EF">L28EF</a> ; to V-RUN/SYN when no more
1 JR NC,<A href="#L28E3">L28E3</a> ; forward to V-TEST-FN if just one character
1 JR NC,<A href="#L2814">L2814</a> ; forward to SF-CP-DEF if a match was found.
1 JR NC,<A href="#L2734">L2734</a> ; forward to S-LOOP if not in table
1 JR NC,<A href="#L2707">L2707</a> ; forward to S-NO-TO-$ with 'sin' through
1 JR NC,<A href="#L26DF">L26DF</a> ; forward to S-NEGATE if not to consider
1 JR NC,<A href="#L26C9">L26C9</a> ; forward to S-LETTER if alpha ->
1 JR NC,<A href="#L2660">L2660</a> ; to S-IK$-STK to stack null string if
1 JR NC,<A href="#L24C4">L24C4</a> ; to DL-X-GE-Y
1 JR NC,<A href="#L2497">L2497</a> ; forward if less than 256 to DRAW-SAVE
1 JR NC,<A href="#L23C1">L23C1</a> ; forward, if > 1, to DR-PRMS
1 JR NC,<A href="#L235A">L235A</a> ; forward, if greater than .5, to C-ARC-GE1
1 JR NC,<A href="#L233B">L233B</a> ; Forward to C-R-GRE-1
1 JR NC,<A href="#L2244">L2244</a> ; to REPORT-K if not 0 or 1.
1 JR NC,<A href="#L2129">L2129</a> ; forward to IN-PR-3 if not.
1 JR NC,<A href="#L1F89">L1F89</a> ; if not then to DEF-FN-4 to jump to
1 JR NC,<A href="#L1EDC">L1EDC</a> ; skip to CLEAR-2 if in actual RAM.
1 JR NC,<A href="#L1EDA">L1EDA</a> ; forward to REPORT-M
1 JR NC,<A href="#L1E9F">L1E9F</a> ; forward to REPORT-B if above.
1 JR NC,<A href="#L1E0A">L1E0A</a> ; forward to READ-1 if DATA found
1 JR NC,<A href="#L1C30">L1C30</a> ; forward to VAR-A-2 if found or checking
1 JR NC,<A href="#L1B6F">L1B6F</a> ; forward to SEPARATOR to check that correct
1 JR NC,<A href="#L19CE">L19CE</a> ; forward to NEXT-O-2 if not a for/next
1 JR NC,<A href="#L19CE">L19CE</a> ; back to NEXT-O-2 if not inverted bit.
1 JR NC,<A href="#L196C">L196C</a> ; to OUT-CH-3 to print digit without
1 JR NC,<A href="#L1765">L1765</a> ; back to REPORT-F if not found
1 JR NC,<A href="#L167F">L167F</a> ; forward to PTR-DONE if var before pos
1 JR NC,<A href="#L11EF">L11EF</a> ; forward to RAM-DONE if we've got back to
1 JR NC,<A href="#L117C">L117C</a> ; forward to ED-C-DONE if no backfilling.
1 JR NC,<A href="#L111B">L111B</a> ; forward to KEY-DONE2 and return with carry
1 JR NC,<A href="#L10FA">L10FA</a> ; forward to KEY-CONTR.
1 JR NC,<A href="#L10DB">L10DB</a> ; skip forward to KEY-M-CL to handle Modes
1 JR NC,<A href="#L0F81">L0F81</a> ; forward to ADD-CHAR if so.
1 JR NC,<A href="#L0F1E">L0F1E</a> ; back to COPY-L-5 if stylus not in position.
1 JR NC,<A href="#L0EFD">L0EFD</a> ; back to COPY-L-1 if stylus of printer not
1 JR NC,<A href="#L0C22">L0C22</a> ; back to PO-EACH if not.
1 JR NC,<A href="#L0B5F">L0B5F</a> ; to PO-T to print tokens
1 JR NC,<A href="#L0B52">L0B52</a> ; to PO-T&UDG to print tokens and UDGs
1 JR NC,<A href="#L0A69">L0A69</a> ; to PO-QUEST to also print '?' if so.
1 JR NC,<A href="#L0912">L0912</a> ; loop back to ME-OLD-V3 if more to test.
1 JR NC,<A href="#L08EB">L08EB</a> ; forward to ME-NEW-L2 if line number in
1 JR NC,<A href="#L0767">L0767</a> ; loop back to LD-LOOK-H until header found.
1 JR NC,<A href="#L0767">L0767</a> ; back to LD-LOOK-H with 4 and over.
1 JR NC,<A href="#L0672">L0672</a> ; forward to SA-V-OLD if variable found.
1 JR NC,<A href="#L064B">L064B</a> ; forward to SA-NAME if length is one to ten.
1 JR NC,<A href="#L05BD">L05BD</a> ; forward to LD-VERIFY if not to be loaded.
1 JR NC,<A href="#L058F">L058F</a> ; back to LD-SYNC if gap too big, that is,
1 JR NC,<A href="#L056C">L056C</a> ; back to LD-START if too close together for a
1 JR NC,<A href="#L056B">L056B</a> ; back to LD-BREAK with time-out.
1 JR NC,<A href="#L056B">L056B</a> ; back to LD-BREAK with time out and no
1 JR NC,<A href="#L056B">L056B</a> ; back to LD-BREAK if time-out
1 JR NC,<A href="#L056B">L056B</a> ; back to LD-BREAK
1 JR NC,<A href="#L051C">L051C</a> ; forward to SA-OUT if bit is 0.
1 JR NC,<A href="#L046C">L046C</a> ; goto REPORT-B
1 JR NC,<A href="#L0427">L0427</a> ; to BE-OCTAVE
1 JR NC,<A href="#L0382">L0382</a> ; to K-8-&-9 if greater than '7'
1 JR NC,<A href="#L02A1">L02A1</a> ; back to KEY-BITS if not pressed
1 JR C,<A href="#L37F8">L37F8</a> ; forward, if less, to SMALL
1 JR C,<A href="#L3703">L3703</a> ; to REPORT-6b
1 JR C,<A href="#L35DC">L35DC</a> ; forward to REPORT-Bd if overflow
1 JR C,<A href="#L3585">L3585</a> ; forward to FRST-LESS if carry set
1 JR C,<A href="#L34E7">L34E7</a> ; to REPORT-A if too low. e.g. usr " ".
1 JR C,<A href="#L34D3">L34D3</a> ; forward to USR-RANGE if ASCII.
1 JR C,<A href="#L325E">L325E</a> ; to T-TEST
1 JR C,<A href="#L31F2">L31F2</a> ; to SUBN-ONLY
1 JR C,<A href="#L31AD">L31AD</a> ; to REPORT-6
1 JR C,<A href="#L3195">L3195</a> ; to OFLOW-CLR
1 JR C,<A href="#L315D">L315D</a> ; to ZERO-RSLT
1 JR C,<A href="#L3151">L3151</a> ; to OFLW2-CLR
1 JR C,<A href="#L30EF">L30EF</a> ; to MULT-OFLW
1 JR C,<A href="#L2F6C">L2F6C</a> ; to PF-E-FRMT
1 JR C,<A href="#L2F46">L2F46</a> ; to PF-NOT-E
1 JR C,<A href="#L2EEC">L2EEC</a> ; to PF-FR-DGT
1 JR C,<A href="#L2ECB">L2ECB</a> ; forward if less to PF-MORE
1 JR C,<A href="#L2E6F">L2E6F</a> ; to PF-MEDIUM if integer <= 2^27
1 JR C,<A href="#L2CEB">L2CEB</a> ; to E-FORMAT if not a digit e.g. '1.'
1 JR C,<A href="#L2CEB">L2CEB</a> ; exit to E-FORMAT when digits exhausted >
1 JR C,<A href="#L2CCF">L2CCF</a> ; to DEC-RPT-C if not
1 JR C,<A href="#L2B3E">L2B3E</a> ; back to L-CHAR with space and less.
1 JR C,<A href="#L2B29">L2B29</a> ; forward to L-SPACES if so.
1 JR C,<A href="#L2B0B">L2B0B</a> ; loop back to L-EACH-CH for more if so.
1 JR C,<A href="#L2AA8">L2AA8</a> ; forward to SL-OVER if start > end.
1 JR C,<A href="#L2A20">L2A20</a> ; to REPORT-3 if > HL
1 JR C,<A href="#L293F">L293F</a> ; to V-FOUND-2 simple and for next
1 JR C,<A href="#L28AB">L28AB</a> ; back to FN-SKPOVR if less
1 JR C,<A href="#L2773">L2773</a> ; forward to S-TIGHTER to execute the
1 JR C,<A href="#L270D">L270D</a> ; forward to S-PUSH-PO if lower as result
1 JR C,<A href="#L26DD">L26DD</a> ; step forward to S-CONT-1 if string ===>
1 JR C,<A href="#L24F7">L24F7</a> ; to D-L-RANGE
1 JR C,<A href="#L24DB">L24DB</a> ; to D-L-HR-VT
1 JR C,<A href="#L24D4">L24D4</a> ; to D-L-DIAG
1 JR C,<A href="#L2495">L2495</a> ; forward, if over 256, to USE-252
1 JR C,<A href="#L2258">L2258</a> ; forward to CO-TEMP-B with 0-7.
1 JR C,<A href="#L2246">L2246</a> ; forward to CO-TEMP-9 if so.
1 JR C,<A href="#L223E">L223E</a> ; forward to CO-TEMP-8 with INK
1 JR C,<A href="#L20AD">L20AD</a> ; forward to INPUT-2 if not.
1 JR C,<A href="#L1F15">L1F15</a> ; forward to REPORT-4 if this passes $FFFF
1 JR C,<A href="#L1F15">L1F15</a> ; forward to REPORT-4 if over $FFFF
1 JR C,<A href="#L1E9F">L1E9F</a> ; forward to REPORT-B if overflow occurred
1 JR C,<A href="#L1D84">L1D84</a> ; forward to REPORT-I if the end of program
1 JR C,<A href="#L1D34">L1D34</a> ; forward to F-L-S if already a FOR/NEXT
1 JR C,<A href="#L1B7D">L1B7D</a> ; step forward to STMT-R-1 if not pressed.
1 JR C,<A href="#L1A15">L1A15</a> ; forward to E-L-1 if overflow i.e. > 65535.
1 JR C,<A href="#L19D5">L19D5</a> ; forward to NEXT-O-3 if within BASIC area.
1 JR C,<A href="#L196C">L196C</a> ; to OUT-CH-3 to output controls and space.
1 JR C,<A href="#L192B">L192B</a> ; back to OUT-SP-1 until no carry from
1 JR C,<A href="#L181F">L181F</a> ; forward to LIST-4 not a '#' .
1 JR C,<A href="#L17E4">L17E4</a> ; to AUTO-L-3 if line 'should' appear
1 JR C,<A href="#L17E1">L17E1</a> ; to AUTO-L-2 if S_TOP higher than E_PPC
1 JR C,<A href="#L1727">L1727</a> ; skip forward to STR-DATA1 if so.
1 JR C,<A href="#L16FC">L16FC</a> ; forward to CLOSE-1 if a non-system stream.
1 JR C,<A href="#L133C">L133C</a> ; forward to MAIN-5 if so.
1 JR C,<A href="#L117C">L117C</a> ; forward to ED-C-DONE if no blanking
1 JR C,<A href="#L103E">L103E</a> ; back to ED-EDGE-1 if cursor not matched.
1 JR C,<A href="#L0F92">L0F92</a> ; forward to ED-KEYS if editing control
1 JR C,<A href="#L0F81">L0F81</a> ; forward to ADD-CHAR also.
1 JR C,<A href="#L0F6C">L0F6C</a> ; forward to ED-CONTR if so
1 JR C,<A href="#L0F0C">L0F0C</a> ; forward to COPY-L-2 if 'break' not pressed.
1 JR C,<A href="#L0DA0">L0DA0</a> ; back to CL-CHAN-A if first pass else done.
1 JR C,<A href="#L0D2D">L0D2D</a> ; forward to PO-SCR-4B if scrolling required
1 JR C,<A href="#L0C86">L0C86</a> ; to REPORT-5 if so
1 JR C,<A href="#L0C86">L0C86</a> ; forward to REPORT-5 if less.
1 JR C,<A href="#L0C22">L0C22</a> ; forward to PO-EACH if not a command, '<>' etc.
1 JR C,<A href="#L0BD3">L0BD3</a> ; to PR-ALL-6 - printer address update
1 JR C,<A href="#L0BA4">L0BA4</a> ; to PR-ALL-2
1 JR C,<A href="#L0B65">L0B65</a> ; to PO-CHAR is so.
1 JR C,<A href="#L0AAC">L0AAC</a> ; to PO-AT-ERR if C was greater than 31d.
1 JR C,<A href="#L0A69">L0A69</a> ; to PO-QUEST to print '?' if so.
1 JR C,<A href="#L0955">L0955</a> ; skip to ME-ENT-2 if variable
1 JR C,<A href="#L082E">L082E</a> ; to LD-DATA
1 JR C,<A href="#L0806">L0806</a> ; forward to REPORT-R if the length on tape is
1 JR C,<A href="#L0554">L0554</a> ; forward to SA/LD-END if not
1 JR C,<A href="#L0367">L0367</a> ; forward to K-DIGIT with digits, space, enter.
1 JR C,<A href="#L0296">L0296</a> ; back to KEY-LINE if still more rows to do.
1 JR C,<A href="#L0090">L0090</a> ; forward to SKIPS with ink, paper, flash,
1 JR <A href="#L35BF">L35BF</a> ; back to exit via STK-PNTRS.
1 JR <A href="#L358C">L358C</a> ; forward to END-TESTS
1 JR <A href="#L3588">L3588</a> ; forward to leave via STR-TEST
1 JR <A href="#L3588">L3588</a> ; forward to STR-TEST
1 JR <A href="#L3564">L3564</a> ; back to BYTE-COMP
1 JR <A href="#L350B">L350B</a> ; to FP-0/1 to overwrite operand with
1 JR <A href="#L350B">L350B</a> ; back to FP-0/1 to overwrite the first operand
1 JR <A href="#L350B">L350B</a> ; back to FP-0/1 to overwrite first operand
1 JR <A href="#L3507">L3507</a> ; forward to SIGN-TO-C
1 JR <A href="#L34B0">L34B0</a> ; exit to STACK-A (via IN-PK-STK to save a byte
1 JR <A href="#L3474">L3474</a> ; forward to NEG-TEST
1 JR <A href="#L33F8">L33F8</a> ; loop back to SKIP-NEXT
1 JR <A href="#L33F1">L33F1</a> ; loop back to STK-ZEROS until done.
1 JR <A href="#L338E">L338E</a> ; forward to ENT-TABLE
1 JR <A href="#L336C">L336C</a> ; back to SCAN-ENT
1 JR <A href="#L31FA">L31FA</a> ; to COUNT-ONE
1 JR <A href="#L31E2">L31E2</a> ; to DIV-START
1 JR <A href="#L3195">L3195</a> ; to OFLOW-CLR
1 JR <A href="#L315D">L315D</a> ; to ZERO-RSLT
1 JR <A href="#L3125">L3125</a> ; to STRT-MLT
1 JR <A href="#L2F85">L2F85</a> ; skip to PF-E-SIGN
1 JR <A href="#L2F5E">L2F5E</a> ; forward to PF-DC-OUT ->
1 JR <A href="#L2F52">L2F52</a> ; back to PF-OUT-LP
1 JR <A href="#L2F0C">L2F0C</a> ; to PF-ROUND
1 JR <A href="#L2F0C">L2F0C</a> ; forward to PF-ROUND
1 JR <A href="#L2EDF">L2EDF</a> ; to PF-FRN-LP
1 JR <A href="#L2E7B">L2E7B</a> ; forward to PF-BITS
1 JR <A href="#L2E01">L2E01</a> ; back to PF-LOOP
1 JR <A href="#L2D60">L2D60</a> ; back to E-LOOP until all bits done.
1 JR <A href="#L2D40">L2D40</a> ; back to NXT-DGT-2 to process as a digit
1 JR <A href="#L2CDA">L2CDA</a> ; back to NXT-DGT-1
1 JR <A href="#L2CD5">L2CD5</a> ; to DEC-STO-1 to add the decimal part to 'x'
1 JR <A href="#L2CA2">L2CA2</a> ; back to BIN-DIGIT for more digits
1 JR <A href="#L2BA6">L2BA6</a> ; forward to L-ENTER ==>
1 JR <A href="#L2B59">L2B59</a> ; back to L-NUMERIC to overwrite value.
1 JR <A href="#L2B0C">L2B0C</a> ; loop back to L-NO-SP.
1 JR <A href="#L2A94">L2A94</a> ; forward to SL-DEFINE.
1 JR <A href="#L2A45">L2A45</a> ; forward to SV-SLICE and make a return
1 JR <A href="#L29E7">L29E7</a> ; forward to SV-COUNT with true no of dims
1 JR <A href="#L295A">L295A</a> ; back to SFA-LOOP while there are more
1 JR <A href="#L294B">L294B</a> ; forward to V-END
1 JR <A href="#L2943">L2943</a> ; back to V-PASS
1 JR <A href="#L2934">L2934</a> ; forward to V-SYNTAX
1 JR <A href="#L2900">L2900</a> ; loop back to V-EACH
1 JR <A href="#L28D4">L28D4</a> ; loop back to V-CHAR
1 JR <A href="#L2843">L2843</a> ; back to SF-ARG-LP looping until all
1 JR <A href="#L2808">L2808</a> ; back to SF-FND-DF to continue search
1 JR <A href="#L27D9">L27D9</a> ; back to SF-ARGMTS to parse all arguments.
1 JR <A href="#L2790">L2790</a> ; forward to S-NEXT
1 JR <A href="#L2764">L2764</a> ; forward to S-RUNTEST
1 JR <A href="#L2734">L2734</a> ; back to S-LOOP to perform these
1 JR <A href="#L2713">L2713</a> ; loop back to S-CONT-3
1 JR <A href="#L26DD">L26DD</a> ; forward to S-CONT-1 ===>
1 JR <A href="#L26C3">L26C3</a> ; to S-NUMERIC to record nature of result
1 JR <A href="#L257D">L257D</a> ; forward to S-SCR-STO
1 JR <A href="#L24DF">L24DF</a> ; to D-L-STEP
1 JR <A href="#L24CB">L24CB</a> ; to DL-LARGER
1 JR <A href="#L2439">L2439</a> ; forward to ARC-START
1 JR <A href="#L22DC">L22DC</a> ; back to PLOT routine to just plot x,y.
1 JR <A href="#L226C">L226C</a> ; forward to exit via routine CO-CHANGE
1 JR <A href="#L226C">L226C</a> ; back to CO-CHANGE addressing MASK_T
1 JR <A href="#L21B2">L21B2</a> ; forward to IN-NEXT-2 to see if anything
1 JR <A href="#L21B2">L21B2</a> ; forward to IN-NEXT-2 as print items
1 JR <A href="#L2161">L2161</a> ; jump forward to IN-VAR-4
1 JR <A href="#L20FA">L20FA</a> ; forward to IN-PROMPT to set up workspace.
1 JR <A href="#L2067">L2067</a> ; skip to PR-POSN-3.
1 JR <A href="#L203C">L203C</a> ; loop back to PR-STRING.
1 JR <A href="#L201E">L201E</a> ; forward to PR-AT-TAB to print the sequence.
1 JR <A href="#L1FCF">L1FCF</a> ; forward to PRINT-1
1 JR <A href="#L1F86">L1F86</a> ; and back to DEF-FN-3
1 JR <A href="#L1EAF">L1EAF</a> ; forward to CLEAR-RUN to clear variables
1 JR <A href="#L1E9C">L1E9C</a> ; forward to FIND-I-1 for common exit routine.
1 JR <A href="#L1E73">L1E73</a> ; forward to GO-TO-2
1 JR <A href="#L1E2C">L1E2C</a> ; back to DATA-1
1 JR <A href="#L1D8B">L1D8B</a> ; back to LOOK-P-1 for next line.
1 JR <A href="#L1D64">L1D64</a> ; back to F-LOOP
1 JR <A href="#L1D16">L1D16</a> ; to F-REORDER
1 JR <A href="#L1C8A">L1C8A</a> ; back to REPORT-C if numeric.
1 JR <A href="#L1C7A">L1C7A</a> ; exit via EXPT-2NUM to check for x,y.
1 JR <A href="#L1C22">L1C22</a> ; back to VAR-A-1
1 JR <A href="#L1BD1">L1BD1</a> ; forward to NEXT-LINE.
1 JR <A href="#L1B55">L1B55</a> ; forward to continue at GET-PARAM
1 JR <A href="#L1B29">L1B29</a> ; forward to continue at STMT-L-1.
1 JR <A href="#L1A30">L1A30</a> ; forward to continue at OUT-NUM-3
1 JR <A href="#L19DB">L19DB</a> ; forward to NEXT-O-5 to add length of
1 JR <A href="#L1974">L1974</a> ; back to LINE-AD-1 for another comparison
1 JR <A href="#L1968">L1968</a> ; to OUT-CH-2 as ':' is within quotes
1 JR <A href="#L1937">L1937</a> ; forward to exit via OUT-CHAR.
1 JR <A href="#L1909">L1909</a> ; forward to OUT-C-2 to print.
1 JR <A href="#L1894">L1894</a> ; back to OUT-LINE4 until entire line is done.
1 JR <A href="#L1835">L1835</a> ; back to LIST-ALL-2.
1 JR <A href="#L17FB">L17FB</a> ; forward to LIST-1
1 JR <A href="#L17CE">L17CE</a> ; to AUTO-L-1 until estimate reached.
1 JR <A href="#L178B">L178B</a> ; to OPEN-END
1 JR <A href="#L178B">L178B</a> ; forward to OPEN-END
1 JR <A href="#L1646">L1646</a> ; forward to CHAN-S-1 for indirect exit
1 JR <A href="#L15F7">L15F7</a> ; forward to CALL-SUB.
1 JR <A href="#L12AC">L12AC</a> ; back to MAIN-2 to allow user to correct.
1 JR <A href="#L12A9">L12A9</a> ; forward to MAIN-1
1 JR <A href="#L117E">L117E</a> ; forward to ED-C-END
1 JR <A href="#L1150">L1150</a> ; back to ED-BLANK until all old text blanked.
1 JR <A href="#L1113">L1113</a> ; forward to KEY-CHAN to change it ...
1 JR <A href="#L1105">L1105</a> ; forward to KEY-DATA with the
1 JR <A href="#L10F4">L10F4</a> ; forward to KEY-FLAG to signal no-key.
1 JR <A href="#L106E">L106E</a> ; forward to ED-LIST to produce an
1 JR <A href="#L1024">L1024</a> ; forward to ED-ENTER to produce error.
1 JR <A href="#L1011">L1011</a> ; forward to ED-CUR to update K-CUR
1 JR <A href="#L0F8B">L0F8B</a> ; forward to ADD-CH-1
1 JR <A href="#L0EDA">L0EDA</a> ; forward to COPY-END to switch off the printer
1 JR <A href="#L0DD9">L0DD9</a> ; exit via CL-SET to set column
1 JR <A href="#L0D8E">L0D8E</a> ; forward to enter the backfill loop at CLS-3
1 JR <A href="#L0C14">L0C14</a> ; forward to PO-TABLE.
1 JR <A href="#L0BC1">L0BC1</a> ; back to PR-ALL-5
1 JR <A href="#L0B7F">L0B7F</a> ; to PR-ALL to print to screen or printer
1 JR <A href="#L0B6A">L0B6A</a> ; to PO-CHAR-2 - common code to lay down
1 JR <A href="#L0AD9">L0AD9</a> ; forward to PO-ABLE.
1 JR <A href="#L0AC3">L0AC3</a> ; forward to PO-FILL
1 JR <A href="#L0A80">L0A80</a> ; forward to PO-CHANGE >>
1 JR <A href="#L0A7D">L0A7D</a> ; forward to PO-TV-1
1 JR <A href="#L0958">L0958</a> ; forward to ME-ENT-3
1 JR <A href="#L0921">L0921</a> ; forward to ME-VAR-L1
1 JR <A href="#L0901">L0901</a> ; back to ME-OLD-V1 to resume search.
1 JR <A href="#L08F9">L08F9</a> ; loop back to ME-OLD-VP
1 JR <A href="#L08F0">L08F0</a> ; loop back to ME-VAR-LP
1 JR <A href="#L08D7">L08D7</a> ; back to ME-OLD-LP until destination position
1 JR <A href="#L08D2">L08D2</a> ; loop back to ME-NEW-LP.
1 JR <A href="#L0825">L0825</a> ; forward to LD-CONT-2
1 JR <A href="#L075A">L075A</a> ; forward to SA-ALL.
1 JR <A href="#L073A">L073A</a> ; forward to SA-TYPE-0 to save program.
1 JR <A href="#L0710">L0710</a> ; forward to SA-TYPE-3
1 JR <A href="#L06F9">L06F9</a> ; forward to SA-CODE-4
1 JR <A href="#L06F0">L06F0</a> ; forward to SA-CODE-2
1 JR <A href="#L05C8">L05C8</a> ; forward to LD-MARKER
1 JR <A href="#L05C4">L05C4</a> ; forward to LD-DEC.
1 JR <A href="#L05C2">L05C2</a> ; forward to LD-NEXT
1 JR <A href="#L0505">L0505</a> ; back to SA-LOOP-P
1 JR <A href="#L0308">L0308</a> ; back to K-END
1 JR <A href="#L0053">L0053</a> ; Forward to continue at ERROR-2.
1 JR <A href="#L001C">L001C</a> ; jump back to TEST-CHAR until a valid
1 JP Z,<A href="#L2BC0">L2BC0</a> ; jump forward if so, to L-NEW$
1 JP Z,<A href="#L28EF">L28EF</a> ; jump back if so to V-RUN/SYN to look in
1 JP Z,<A href="#L28EF">L28EF</a> ; JUMP back to V-RUN/SYN, if so, as there are
1 JP Z,<A href="#L270D">L270D</a> ; to S-PUSH-PO if so to use the calculator
1 JP Z,<A href="#L21B2">L21B2</a> ; forward to IN-NEXT-2 if checking syntax.
1 JP Z,<A href="#L20C1">L20C1</a> ; jump back to IN-ITEM-1 if the zero flag
1 JP Z,<A href="#L1C8A">L1C8A</a> ; jump back to REPORT-C if so.
1 JP Z,<A href="#L1B28">L1B28</a> ; to STMT-LOOP if result zero as statement is
1 JP Z,<A href="#L1B28">L1B28</a> ; jump back to STMT-LOOP to consider
1 JP Z,<A href="#L1097">L1097</a> ; jump to CLEAR-SP if so.
1 JP Z,<A href="#L101E">L101E</a> ; jump to ED-IGNORE if not, else
1 JP Z,<A href="#L0970">L0970</a> ; jump forward to SA-CONTRL with SAVE ->
1 JP Z,<A href="#L08B6">L08B6</a> ; jump forward to ME-CONTRL if so.
1 JP Z,<A href="#L0808">L0808</a> ; JUMP forward to LD-CONTRL if so to
1 JP Z,<A href="#L0018">L0018</a> ; jump to exit via get-char pointing at
1 JP PO,<A href="#L046C">L046C</a> ; if pitch <= 67 goto REPORT-B
1 JP P,<A href="#L3380">L3380</a> ; forward to FIRST-3D if in range $00 - $3D
1 JP P,<A href="#L3146">L3146</a> ; to OFLW1-CLR
1 JP P,<A href="#L2F83">L2F83</a> ; to PF-E-POS if positive
1 JP P,<A href="#L293F">L293F</a> ; to V-FOUND-2 strings and arrays
1 JP P,<A href="#L04D8">L04D8</a> ; back to SA-LEADER until H becomes $FF
1 JP P,<A href="#L0425">L0425</a> ; goto BE-i-OK
1 JP NZ,<A href="#L2DE3">L2DE3</a> ; to PRINT-FP to print if numeric >>>
1 JP NZ,<A href="#L2AFF">L2AFF</a> ; jump forward to LET to make the assignment
1 JP NZ,<A href="#L2951">L2951</a> ; JUMP to STK-F-ARG in runtime and then
1 JP NZ,<A href="#L1C8A">L1C8A</a> ; jump forward to REPORT-C with anything else.
1 JP NZ,<A href="#L1C8A">L1C8A</a> ; jump forward to REPORT-C if not
1 JP NZ,<A href="#L1C8A">L1C8A</a> ; jump back to REPORT-C if not.
1 JP NZ,<A href="#L1C8A">L1C8A</a> ; jump back to REPORT-C if not string
1 JP NZ,<A href="#L1C8A">L1C8A</a> ; jump back to REPORT-C if not
1 JP NZ,<A href="#L1C8A">L1C8A</a> ; Jump, if not, to REPORT-C
1 JP NZ,<A href="#L1C2E">L1C2E</a> ; jump back to REPORT-2 if so
1 JP NZ,<A href="#L155D">L155D</a> ; jump forward to MAIN-ADD if so to add the
1 JP NZ,<A href="#L1097">L1097</a> ; jump forward to CLEAR-SP if not in editor.
1 JP NZ,<A href="#L0ECD">L0ECD</a> ; to COPY-BUFF if so, to flush buffer and reset
1 JP NZ,<A href="#L0D02">L0D02</a> ; jump forward to PO-SCR-4 if so.
1 JP NZ,<A href="#L0C55">L0C55</a> ; exit to PO-SCR to test for scrolling
1 JP NZ,<A href="#L0514">L0514</a> ; JUMP back to SA-BIT-1
1 JP NZ,<A href="#L04FE">L04FE</a> ; JUMP to SA-LOOP if more bytes.
1 JP NZ,<A href="#L03D6">L03D6</a> ;(10) ; to BE-H&L-LP
1 JP NC,<A href="#L2684">L2684</a> ; jump forward to S-ALPHNUM if not in primary
1 JP NC,<A href="#L21AF">L21AF</a> ; forward to IN-NEXT-1 if not
1 JP NC,<A href="#L1E9F">L1E9F</a> ; JUMP to REPORT-Bb if not in range 0 - 15.
1 JP NC,<A href="#L1C8A">L1C8A</a> ; to REPORT-C if higher
1 JP NC,<A href="#L1C8A">L1C8A</a> ; jump to REPORT-C if not.
1 JP NC,<A href="#L1C8A">L1C8A</a> ; jump back to REPORT-C if not
1 JP NC,<A href="#L160E">L160E</a> ; jump back to REPORT-Oa if not
1 JP NC,<A href="#L0AD9">L0AD9</a> ; jump forward to PO-ABLE if so.
1 JP NC,<A href="#L05CA">L05CA</a> ; JUMP back to LD-8-BITS
1 JP M,<A href="#L31D2">L31D2</a> ; to DIV-LOOP
1 JP M,<A href="#L31AD">L31AD</a> ; to REPORT-6 if over '127'.
1 JP M,<A href="#L2F52">L2F52</a> ; skip forward to PF-OUT-LP if originally +ve
1 JP M,<A href="#L2A20">L2A20</a> ; jump back to REPORT-3 if $FF.
1 JP M,<A href="#L1C8A">L1C8A</a> ; to REPORT-C to raise
1 JP M,<A href="#L1C8A">L1C8A</a> ; to REPORT-C if not string result
1 JP M,<A href="#L19C7">L19C7</a> ; forward to NEXT-O-1 if so
1 JP M,<A href="#L039D">L039D</a> ; jump to K-KLC-DGT if was 0.
1 JP M,<A href="#L034F">L034F</a> ; to K-KLC-LET if was zero
1 JP C,<A href="#L31AD">L31AD</a> ; to REPORT-6 if overflow - too many digits
1 JP C,<A href="#L31AD">L31AD</a> ; to REPORT-6 if overflow (over 255)
1 JP C,<A href="#L2A20">L2A20</a> ; to REPORT-3 if > 65280 and then some
1 JP C,<A href="#L24F9">L24F9</a> ; jump forward to REPORT-Bc if greater.
1 JP C,<A href="#L24F9">L24F9</a> ; jump forward to REPORT-Bc if >= 255.5.
1 JP C,<A href="#L2477">L2477</a> ; forward, if the coordinates of first line
1 JP C,<A href="#L2211">L2211</a> ; to CO-TEMP-5
1 JP C,<A href="#L1F15">L1F15</a> ; to REPORT-4 if > 65535
1 JP C,<A href="#L1F15">L1F15</a> ; jump back to REPORT-4 if over 65535.
1 JP C,<A href="#L1C8A">L1C8A</a> ; jump to REPORT-C if less than a command
1 JP C,<A href="#L1C8A">L1C8A</a> ; jump back to REPORT-C with anything else
1 JP C,<A href="#L1C2E">L1C2E</a> ; jump back to REPORT-2 if variable not found
1 JP C,<A href="#L1BB3">L1BB3</a> ; jump to LINE-END if FALSE (0)
1 JP C,<A href="#L0C86">L0C86</a> ; to REPORT-5 if too low
1 JP <A href="#L36C4">L36C4</a> ; jump back to EXP routine ->
1 JP <A href="#L35BF">L35BF</a> ; jump back to STK-PNTRS
1 JP <A href="#L3155">L3155</a> ; to TEST-NORM
1 JP <A href="#L313D">L313D</a> ; jump back to DIVN-EXPT
1 JP <A href="#L2ECF">L2ECF</a> ; JUMP forward to PF-FRACTN
1 JP <A href="#L2D2B">L2D2B</a> ; Jump back to STACK-BC to save result on the
1 JP <A href="#L2D2B">L2D2B</a> ; JUMP to STACK-BC to put on calculator stack
1 JP <A href="#L2D28">L2D28</a> ; jump forward to STACK-A to save result.
1 JP <A href="#L2D28">L2D28</a> ; forward to STACK-A to store result
1 JP <A href="#L2A49">L2A49</a> ; jump forward to SV-SLICE? to test for '('
1 JP <A href="#L2712">L2712</a> ; to S-CONT-2 - to continue current
1 JP <A href="#L26C3">L26C3</a> ; jump forward to S-NUMERIC
1 JP <A href="#L25DB">L25DB</a> ; forward to S-STRING to stack result
1 JP <A href="#L24FF">L24FF</a> ; to S-LOOP-1
1 JP <A href="#L24FF">L24FF</a> ; jump back to S-LOOP-1 to go round the loop
1 JP <A href="#L24FF">L24FF</a> ; jump back to S-LOOP-1
1 JP <A href="#L2477">L2477</a> ; to LINE-DRAW
1 JP <A href="#L2477">L2477</a> ; jump forward to LINE-DRAW
1 JP <A href="#L2477">L2477</a> ; forward to LINE-DRAW
1 JP <A href="#L2420">L2420</a> ; forward to DRW-STEPS
1 JP <A href="#L22DC">L22DC</a> ; JUMP to PLOT
1 JP <A href="#L21B2">L21B2</a> ; forward to IN-NEXT-2
1 JP <A href="#L1E73">L1E73</a> ; to GO-TO-2 to update statement and line
1 JP <A href="#L1E73">L1E73</a> ; exit via GO-TO-2 to execute another loop.
1 JP <A href="#L1E39">L1E39</a> ; jump back to PASS-BY
1 JP <A href="#L1C8A">L1C8A</a> ; to REPORT-C (REPORT-Cb is within range)
1 JP <A href="#L1C8A">L1C8A</a> ; jump to REPORT-C with any other character
1 JP <A href="#L1A1B">L1A1B</a> ; exit via OUT-NUM-1 to print exponent in BC
1 JP <A href="#L19E8">L19E8</a> ; to RECLAIM-2 reclaim the character.
1 JP <A href="#L19E8">L19E8</a> ; jump to indirect exit via RECLAIM-2
1 JP <A href="#L19E5">L19E5</a> ; jump forward to RECLAIM-1.
1 JP <A href="#L198B">L198B</a> ; to EACH-STMT to find next statement
1 JP <A href="#L16C5">L16C5</a> ; jump back to SET-STK to set the calculator
1 JP <A href="#L16C5">L16C5</a> ; Jump to SET-STK to clear the calculator stack
1 JP <A href="#L169E">L169E</a> ; Jump forward to continuation code RESERVE.
1 JP <A href="#L1601">L1601</a> ; exit via CHAN-OPEN to ED-LOOP
1 JP <A href="#L15EF">L15EF</a> ; jump back to exit via OUT-CODE. ->
1 JP <A href="#L1313">L1313</a> ; jump back to MAIN-G
1 JP <A href="#L12AC">L12AC</a> ; jump back to MAIN-2.
1 JP <A href="#L12A2">L12A2</a> ; and back to MAIN-EXEC producing a listing
1 JP <A href="#L11CB">L11CB</a> ; Jump forward to common code at START-NEW.
1 JP <A href="#L0F30">L0F30</a> ; to ED-AGAIN to re-stack address of
1 JP <A href="#L0DD9">L0DD9</a> ; jump forward to CL-SET to store new position.
1 JP <A href="#L0DD9">L0DD9</a> ; exit via CL-SET and then PO-STORE.
1 JP <A href="#L0D6E">L0D6E</a> ; jump back to CLS-LOWER and make
1 JP <A href="#L0D4D">L0D4D</a> ; to TEMPS
1 JP <A href="#L0D4D">L0D4D</a> ; jump back to TEMPS and exit via that
1 JP <A href="#L0D4D">L0D4D</a> ; jump back and exit via TEMPS >>>
1 JP <A href="#L0BDB">L0BDB</a> ; exit to PO-ATTR to set colours for cell.
1 JP <A href="#L0B03">L0B03</a> ; exit via a JUMP to PO-FETCH as this routine
1 JP <A href="#L0B03">L0B03</a> ; Jump forward to PO-FETCH,
1 JP <A href="#L0ADC">L0ADC</a> ; exit via PO-STORE to update the relevant
1 JP <A href="#L0802">L0802</a> ; jump back to LD-BLOCK
1 JP <A href="#L0802">L0802</a> ; JUMP back to LD-BLOCK
1 JP <A href="#L075A">L075A</a> ; jump forward to SA-ALL
1 JP <A href="#L0525">L0525</a> ; JUMP forward to SA-8-BITS -8->
1 JP <A href="#L0507">L0507</a> ; JUMP forward to SA-START ->
1 JP <A href="#L04C2">L04C2</a> ; jump back to SA-BYTES
1 JP <A href="#L03B5">L03B5</a> ; to BEEPER
1 JP <A href="#L0055">L0055</a> ; jump back to ERROR-3 at $0055
1 JP (IX) ;(8) ; do high pulse of tone
1 JP (IX) ;(8) ; do another cycle
1 JP (HL) ; now jump forward to the relevant routine.
1 JP (HL) ; jump to that routine.
1 JP (HL) ; jump to routine ( i.e. L0000 )
1 JP (HL) ; jump to return address as BASIC program is
1 JP (HL) ; and jump to the routine e.g. S-BIN
1 JP (HL) ; and go there directly.
1 JP Z,<A href="#L1C8A">L1C8A</a> ; jump to REPORT-C if so.
1 INC SP ; adjust to overwrite unimportant byte
1 INC IX ; increase byte pointer
1 INC HL ; update to start of 'A' in RAM.
1 INC HL ; to point to low byte of input routine.
1 INC HL ; to point to first location.
1 INC HL ; to first new location
1 INC HL ; to address Number of dimensions.
1 INC HL ; then to second.
1 INC HL ; the total length
1 INC HL ; the supplied
1 INC HL ; the normal
1 INC HL ; the input routine.
1 INC HL ; the
1 INC HL ; step past variable name
1 INC HL ; step past the jump length.
1 INC HL ; step past single character variable name.
1 INC HL ; step past
1 INC HL ; step over the second character of 'at'/'tab'.
1 INC HL ; step over the
1 INC HL ; step over output routine
1 INC HL ; step
1 INC HL ; skip the character
1 INC HL ; skip over the exponent.
1 INC HL ; skip over the
1 INC HL ; skip low number byte.
1 INC HL ; set HL to next location.
1 INC HL ; routine address for
1 INC HL ; point to start of string descriptor
1 INC HL ; point to start of required string.
1 INC HL ; point to start of new area.
1 INC HL ; point to start of BASIC/variable contents.
1 INC HL ; point to next source byte if not
1 INC HL ; point to next location the 16-bit counter
1 INC HL ; point to high byte.
1 INC HL ; point to high byte of length.
1 INC HL ; point to first new location.
1 INC HL ; point to first new location and
1 INC HL ; point to first byte of number
1 INC HL ; point to 5th.
1 INC HL ; past space
1 INC HL ; past
1 INC HL ; output streams
1 INC HL ; output routine.
1 INC HL ; output address
1 INC HL ; or the input address on the second pass.
1 INC HL ; of line number.
1 INC HL ; number
1 INC HL ; now point to third location.
1 INC HL ; now increment the pointer.
1 INC HL ; now address the hidden marker.
1 INC HL ; next to high byte
1 INC HL ; next location becomes
1 INC HL ; next location
1 INC HL ; next address.
1 INC HL ; next address
1 INC HL ; make HL address limit.
1 INC HL ; length bytes.
1 INC HL ; input and
1 INC HL ; increment the length for inclusive byte.
1 INC HL ; increment source
1 INC HL ; increment bitmap address.
1 INC HL ; increment as a starting point.
1 INC HL ; increment a third time for 'at'/'tab'
1 INC HL ; increment 2nd string pointer.
1 INC HL ; increase to address high byte
1 INC HL ; increase screen/printer position
1 INC HL ; increase pointer.
1 INC HL ; increase pointer'
1 INC HL ; increase pointer within variable.
1 INC HL ; in the next
1 INC HL ; if -128<=p<=127, MSB will be 0/FF if B is pos/neg
1 INC HL ; following.
1 INC HL ; followed by
1 INC HL ; five
1 INC HL ; bytes.
1 INC HL ; bump workspace address.
1 INC HL ; and the two
1 INC HL ; and pointer
1 INC HL ; and increment for next iteration.
1 INC HL ; and five bytes
1 INC HL ; and digit characters
1 INC HL ; and advance address
1 INC HL ; and address the letter.
1 INC HL ; all above have at least one extra character
1 INC HL ; advance to the interrupt counter
1 INC HL ; advance to the delay
1 INC HL ; advance to start of next line.
1 INC HL ; advance to second
1 INC HL ; advance to last location of state map.
1 INC HL ; advance to high byte
1 INC HL ; advance to first new location.
1 INC HL ; advance pointer
1 INC HL ; advance past the expected '$' to
1 INC HL ; advance both
1 INC HL ; adjust for carry.
1 INC HL ; adjust HL (set by LDDR)
1 INC HL ; address unused byte
1 INC HL ; address the next location.
1 INC HL ; address the first new location
1 INC HL ; address the first byte of mantissa.
1 INC HL ; address the 5-counter
1 INC HL ; address start of string
1 INC HL ; address start of data.
1 INC HL ; address sign byte and
1 INC HL ; address sign byte
1 INC HL ; address next one.
1 INC HL ; address next location. <font color=#9900FF>Note.</font> not INC L.
1 INC HL ; address next leftmost character to
1 INC HL ; address next expected character
1 INC HL ; address next digit
1 INC HL ; address next character (first in quotes)
1 INC HL ; address next character
1 INC HL ; address next byte and
1 INC HL ; address next byte - <font color=#9900FF>Note.</font> not INC L.
1 INC HL ; address next as at least one parameter.
1 INC HL ; address mantissa
1 INC HL ; address low byte of length.
1 INC HL ; address low byte of integer
1 INC HL ; address low byte of
1 INC HL ; address looping statement
1 INC HL ; address length high
1 INC HL ; address known zero indicator of 1st number
1 INC HL ; address high byte of integer.
1 INC HL ; address high byte in STRMS.
1 INC HL ; address first location
1 INC HL ; address first byte of mantissa
1 INC HL ; address fifth byte.
1 INC HL ; address MEM-5-2 total digits
1 INC HL ; address 2nd location
1 INC HL ; Step past the jump length.
1 INC HL ; Increment lowest two bytes of counter.
1 INC HL ; Increment again.
1 INC HL ; HL now location after new space
1 INC HL ; HL now addresses first byte of filename.
1 INC HL ; Advance address.
1 INC H ; proceed to test 256 edged sample.
1 INC H ; next pixel line down.
1 INC H ; next line down screen within 'thirds'.
1 INC H ; increment the dimension counter
1 INC H ; increment it
1 INC H ; address next line down.
1 INC E ;
1 INC DE ; third byte
1 INC DE ; points to end of new area.
1 INC DE ; pointers.
1 INC DE ; next location.
1 INC DE ; make DE point to next location.
1 INC DE ; make DE point to next byte.
1 INC DE ; increment length ??
1 INC DE ; increment destination
1 INC DE ; increment 1st string pointer.
1 INC DE ; increase the destination pointer
1 INC DE ; increase length by one.
1 INC DE ; increase length
1 INC DE ; increase destination pointer.
1 INC DE ; increase destination
1 INC DE ; for letter name
1 INC DE ; bump prog address.
1 INC DE ; and advance address
1 INC DE ; and 16-bit length
1 INC DE ; advance destination address.
1 INC DE ; address next.
1 INC DE ; address next location.
1 INC DE ; address next character in workspace area.
1 INC DE ; address next
1 INC DE ; Address next character in the table.
1 INC D ; increment statement.
1 INC D ; gives next pixel line down screen
1 INC D ; else restore statement.
1 INC D ;
1 INC C ;(4) ; adds 16 cycles to make duration of high = duration of low
1 INC C ;(4) ;
1 INC C ; increment matched character count
1 INC C ; increase length to one.
1 INC C ; flag
1 INC C ; and increment to give number of bytes
1 INC BC ; two bytes
1 INC BC ; to include character and length bytes.
1 INC BC ; three bytes also.
1 INC BC ; restore true length.
1 INC BC ; restore counter to zero.
1 INC BC ; one for the pot.
1 INC BC ; of line number (two bytes)
1 INC BC ; letter name and total length.
1 INC BC ; length to include
1 INC BC ; length by three
1 INC BC ; increment the length for a carriage return.
1 INC BC ; increment as we also copy byte at old STKEND.
1 INC BC ; increase length counter.
1 INC BC ; increase
1 INC BC ; include these
1 INC BC ; if it was AT/TAB - 3 locations required
1 INC BC ; for the length of string.
1 INC BC ; extra byte for letter.
1 INC BC ; and line length
1 INC BC ; adjust the
1 INC BC ; adjust length to
1 INC BC ; adjust for inclusion
1 INC BC ; add a byte.
1 INC BC ; (two bytes).
1 INC BC ;
1 INC B ; the high byte is zero.
1 INC B ; test if shift pressed.
1 INC B ; test B is it empty i.e. not a shift.
1 INC B ; shift ?
1 INC B ; set sign to zero
1 INC B ; set OVER mask to 0
1 INC B ; now test if we arrived here from NEW.
1 INC B ; move up one screen line
1 INC B ; make B hold 1 also.
1 INC B ; is shift being pressed ?
1 INC B ; increment to give rotation count 1-8.
1 INC B ; increment high byte.
1 INC B ; increment B
1 INC B ; increase to address last line of display
1 INC B ; increase 1-8.
1 INC B ; destructively test for shift
1 INC B ; adjust to system range $02-$18
1 INC B ; $FF to $00 or $00 to $01 - expendable now.
1 INC A ; zero flag set if replacement.
1 INC A ; without altering carry.
1 INC A ; value 255.
1 INC A ; that is, initially zero.
1 INC A ; test if now $FF by incrementing.
1 INC A ; test for no error originally $FF.
1 INC A ; set type to 2 - string array.
1 INC A ; set to $00 if inverse
1 INC A ; set A to 1, simple string.
1 INC A ; reset zero flag i.e. NZ.
1 INC A ; make range 1-21d to match LSBs of ASCII
1 INC A ; increment.
1 INC A ; increment to give true code.
1 INC A ; increment digit
1 INC A ; if it is zero we have at most 1 key
1 INC A ; else change from INK to PAPER (17d) if so.
1 INC A ; augment from 'K' to 'L'.
1 INC A ; and zero flag.
1 INC A ; and increment
1 INC A ; adjust for system range $01-$17
1 INC A ; adjust for initial step-over byte
1 INC (IY+$72) ; make MEM-5-2nd hold 1.
1 INC (IY+$72) ; increment MEM-5-2nd leading digit counter
1 INC (IY+$71) ; increment MEM-5-1st digit counter
1 INC (IY+$71) ; MEM-5-1st
1 INC (IY+$62) ; Increment MEM-2-1st doubling half chord.
1 INC (IY+$40) ; otherwise increment FRAMES3 the third byte.
1 INC (IY+$0F) ; restore E_PPC_lo to the previous value.
1 INC (IY+$0D) ; increment statement number SUBPPC
1 INC (HL) ; increment the exponent leaving pi
1 INC (HL) ; else increment S_POSN_hi
1 INC D ;
1 IN A,(C) ; Read the port.
1 IN A,($FE) ; row with the space key at outside.
1 IN A,($FE) ; row $7FFE. bit 6 is EAR, bit 0 is SPACE key.
1 IN A,($FE) ; return to common exit (to restore border)
1 IN A,($FE) ; read the ear state - bit 6.
1 IN A,($FE) ; read lower right keys
1 IN A,($FE) ; read lower left keys
1 IM 1 ; select interrupt mode 1.
1 EXX ; switch to main set.
1 EXX ; switch to alternate set.
1 EXX ; switch to alternate set
1 EXX ; switch in the main set.
1 EXX ; switch in main set.
1 EXX ; switch back.
1 EXX ; switch back to the main set and
1 EXX ; switch back to main set.
1 EXX ; switch back to alternate set.
1 EXX ; swap
1 EXX ; str$ as H'L' will be used.
1 EXX ; regardless of state, set up possibly
1 EXX ; main set
1 EXX ; in case called from 'str$' then save the
1 EXX ; Switch to the other set.
1 EXX ; Switch in the main set.
1 EXX ; Switch in main set
1 EXX ; Switch in alternate set.
1 EXX ; Switch back to this alternate set.
1 EXX ; Switch back to main set.
1 EXX ; Switch back to main set and continue into...
1 EXX ; Else switch in the pointer set.
1 EX DE,HL ; was less so transfer to DE
1 EX DE,HL ; transfer to HL.
1 EX DE,HL ; transfer to HL
1 EX DE,HL ; transfer to DE ?? pop straight into de ?
1 EX DE,HL ; transfer the stream to HL.
1 EX DE,HL ; transfer start to HL.
1 EX DE,HL ; transfer result to DE if looping again.
1 EX DE,HL ; transfer program dest pointer to HL.
1 EX DE,HL ; transfer program dest pointer back to DE.
1 EX DE,HL ; transfer prog pointer to HL
1 EX DE,HL ; transfer pointer to HL
1 EX DE,HL ; transfer old value of STKEND to HL.
1 EX DE,HL ; transfer offset to HL, STRMS data pointer
1 EX DE,HL ; transfer number to HL
1 EX DE,HL ; transfer next address to HL.
1 EX DE,HL ; transfer new address to DE
1 EX DE,HL ; transfer first location to HL.
1 EX DE,HL ; transfer destination address to DE, start
1 EX DE,HL ; transfer attribute address to DE
1 EX DE,HL ; transfer address to DE
1 EX DE,HL ; transfer ECHO_E to DE
1 EX DE,HL ; transfer DE to HL
1 EX DE,HL ; switch. DE = location after first new space
1 EX DE,HL ; switch the pointer to HL.
1 EX DE,HL ; switch source and destination
1 EX DE,HL ; switch so next in HL
1 EX DE,HL ; switch pointers and make the UDGs a
1 EX DE,HL ; swap source and destination addresses.
1 EX DE,HL ; swap registers
1 EX DE,HL ; swap pointer to DE before
1 EX DE,HL ; swap it to DE, HL points to last of
1 EX DE,HL ; swap - HL is start, DE is destination.
1 EX DE,HL ; statement to D, BASIC line number to HL.
1 EX DE,HL ; start to HL, length to DE.
1 EX DE,HL ; start of string/subscript to DE
1 EX DE,HL ; start address to HL
1 EX DE,HL ; set HL to location after value in DEF FN
1 EX DE,HL ; set DE to second location.
1 EX DE,HL ; save the pointer to the letter in DE.
1 EX DE,HL ; save the pointer in DE.
1 EX DE,HL ; save the buffer
1 EX DE,HL ; save start of BASIC in DE.
1 EX DE,HL ; save running total in DE
1 EX DE,HL ; save result in DE bringing back sign pointer
1 EX DE,HL ; save pointer to dimensions in DE
1 EX DE,HL ; save pointer to '$' in DE
1 EX DE,HL ; save pointer in DE
1 EX DE,HL ; save letter pointer and bring back
1 EX DE,HL ; save kstate-0 in de
1 EX DE,HL ; save STRMS address in DE.
1 EX DE,HL ; save HL to DE.
1 EX DE,HL ; save HL address in DE.
1 EX DE,HL ; restore the source and destination.
1 EX DE,HL ; restore pointers.
1 EX DE,HL ; restore pointers.
1 EX DE,HL ; restore pointers
1 EX DE,HL ; restore address pointer to HL.
1 EX DE,HL ; restore HL from DE
1 EX DE,HL ; put start in DE.
1 EX DE,HL ; put STMT-RET in HL.
1 EX DE,HL ; pointer to DE, start of string to HL.
1 EX DE,HL ; offset to HL, program address to DE.
1 EX DE,HL ; now to HL, FN ')' pointer to DE.
1 EX DE,HL ; now make HL workspace pointer, DE vars pointer
1 EX DE,HL ; new free location to HL.
1 EX DE,HL ; make workspace pointer source, prog/vars
1 EX DE,HL ; make HL point to result and DE to STKEND.
1 EX DE,HL ; make HL point to exponent/zero indicator
1 EX DE,HL ; make HL point to deleted value
1 EX DE,HL ; make DE destination.
1 EX DE,HL ; line number to HL,
1 EX DE,HL ; length to HL,
1 EX DE,HL ; integer to HL
1 EX DE,HL ; exchange pointers.
1 EX DE,HL ; even up the exchanges so that DE addresses
1 EX DE,HL ; end of string + 1 to HL
1 EX DE,HL ; else use address of next line.
1 EX DE,HL ; dimensions pointer to HL to synchronize
1 EX DE,HL ; destination to HL
1 EX DE,HL ; data pointer to DE, dim size to HL.
1 EX DE,HL ; character address to DE
1 EX DE,HL ; buffer to HL
1 EX DE,HL ; bring back variables data pointer.
1 EX DE,HL ; bring back pointer to previous or edit line
1 EX DE,HL ; bring back KSTATE-0
1 EX DE,HL ; back to DE
1 EX DE,HL ; as we were.
1 EX DE,HL ; and switch pointers
1 EX DE,HL ; and previous in DE
1 EX DE,HL ; address of next line to HL.
1 EX DE,HL ; address first number again
1 EX DE,HL ; address 4th byte, normalized int to DE
1 EX DE,HL ; Swap pointers. HL points to program area.
1 EX DE,HL ; HL now addresses the top of the area to
1 EX DE,HL ; HL addresses length low
1 EX DE,HL ; HL = last value, DE = STKEND.
1 EX DE,HL ; DE = start now.
1 EX DE,HL ; DE = STKEND
1 EX AF,AF' ; store the flags.
1 EX AF,AF' ; save flag??
1 EX AF,AF' ; restore saved flag
1 EX AF,AF' ; restore flags.
1 EX AF,AF' ; restore flag
1 EX AF,AF' ; preserve entry flags.
1 EX AF,AF' ; fetch the flag
1 EX AF,AF' ; fetch flags back.
1 EX (SP),HL ; swap with prog/vars pointer on stack.
1 EX (SP),HL ; swap with line address on stack
1 EX (SP),HL ; swap with length on stack
1 EX (SP),HL ; swap with DEF FN address on stack ***
1 EX (SP),HL ; swap result with top line number on stack.
1 EX (SP),HL ; swap pos with system variable pointer
1 EX (SP),HL ; swap pointer on stack with the variable
1 EX (SP),HL ; swap - error address to HL,
1 EX (SP),HL ; statement to H, error address to base of
1 EX (SP),HL ; start pointer to stack, data pointer to HL.
1 EX (SP),HL ; start address to stack, end point to HL (*)
1 EX (SP),HL ; put length2 on stack, bring start2 to HL *.
1 EX (SP),HL ; put end point on stack, start address to HL
1 EX (SP),HL ; put HL on stack as next literal pointer
1 EX (SP),HL ; pointer to HL, destination to stack.
1 EX (SP),HL ; ld h,0; push hl would have done ?.
1 EX (SP),HL ; goes to stack
1 EX (SP),HL ; exchange with ECHO_E on stack
1 EX (SP),HL ; dim pointer to stack, data pointer to HL (*)
1 EX (SP),HL ; and store the address of next instruction,
1 EX (SP),HL ; Transfer H'L' to machine stack for the
1 EX (SP),HL ; (*) length to HL, pointer to stack.
1 EX (SP),HL ;
1 EI ; enable interrupts now that we have a stack.
1 EI ; enable interrupts
1 EI ; Enable Interrupts.
1 DJNZ <A href="#L343E">L343E</a> ; loop back to SWAP-BYTE until all 5 done.
1 DJNZ <A href="#L328A">L328A</a> ; to LESS-MASK
1 DJNZ <A href="#L327E">L327E</a> ; to BYTE-ZERO
1 DJNZ <A href="#L3261">L3261</a> ; to T-SHIFT
1 DJNZ <A href="#L316E">L316E</a> ; to SHIFT-ONE
1 DJNZ <A href="#L3114">L3114</a> ; to MLT-LOOP
1 DJNZ <A href="#L2FE5">L2FE5</a> ; to ONE-SHIFT
1 DJNZ <A href="#L2FAF">L2FAF</a> ; loop to NEG-BYTE till all 5 done
1 DJNZ <A href="#L2F64">L2F64</a> ; loop back to PF-DEC-0S for B times.
1 DJNZ <A href="#L2F52">L2F52</a> ; loop back to PF-OUT-LP until B leading
1 DJNZ <A href="#L2EEF">L2EEF</a> ; to PF-FR-EXX
1 DJNZ <A href="#L2E7B">L2E7B</a> ; back to PF-BITS until 8 or 16 (or 32) done
1 DJNZ <A href="#L2B3E">L2B3E</a> ; loop back to L-CHAR until B is zero.
1 DJNZ <A href="#L29C3">L29C3</a> ; back to SV-COMMA if more dimensions
1 DJNZ <A href="#L255D">L255D</a> ; back to S-SC-ROWS until all eight matched.
1 DJNZ <A href="#L254F">L254F</a> ; back to S-SCRN-LP if more characters.
1 DJNZ <A href="#L24CE">L24CE</a> ; to D-L-LOOP
1 DJNZ <A href="#L2425">L2425</a> ; Decrement and loop while > 0 to ARC-LOOP
1 DJNZ <A href="#L22F0">L22F0</a> ; to PLOT-LOOP until B circular rotations.
1 DJNZ <A href="#L22D4">L22D4</a> ; to POINT-LP until pixel at right.
1 DJNZ <A href="#L0F18">L0F18</a> ; loop back to COPY-L-4 for all 8 bits.
1 DJNZ <A href="#L0EE7">L0EE7</a> ; back to PRB-BYTES. repeat for 256 bytes.
1 DJNZ <A href="#L0ED3">L0ED3</a> ; loop back to COPY-3 for all 8 lines.
1 DJNZ <A href="#L0CF0">L0CF0</a> ; loop back to PO-SCR-3A for all adjacent
1 DJNZ <A href="#L0991">L0991</a> ; back to SA-1-SEC until pause complete.
1 DJNZ <A href="#L07A6">L07A6</a> ; loop back to LD-NAME for ten characters.
1 DJNZ <A href="#L0629">L0629</a> ; loop back to SA-BLANK till all eleven done.
1 DEFW <A href="#L3851">L3851</a> ; $06 Address: $3851 - to-power
1 DEFW <A href="#L384A">L384A</a> ; $28 Address: $384A - sqr
1 DEFW <A href="#L3843">L3843</a> ; $23 Address: $3843 - acs
1 DEFW <A href="#L3833">L3833</a> ; $22 Address: $3833 - asn
1 DEFW <A href="#L37E2">L37E2</a> ; $24 Address: $37E2 - atn
1 DEFW <A href="#L37DA">L37DA</a> ; $21 Address: $37DA - tan
1 DEFW <A href="#L37B5">L37B5</a> ; $1F Address: $37B5 - sin
1 DEFW <A href="#L37AA">L37AA</a> ; $20 Address: $37AA - cos
1 DEFW <A href="#L3783">L3783</a> ; $39 Address: $3783 - get-argt
1 DEFW <A href="#L3713">L3713</a> ; $25 Address: $3713 - ln
1 DEFW <A href="#L36C4">L36C4</a> ; $26 Address: $36C4 - exp
1 DEFW <A href="#L36AF">L36AF</a> ; $27 Address: $36AF - int
1 DEFW <A href="#L36A0">L36A0</a> ; $32 Address: $36A0 - n-mod-m
1 DEFW <A href="#L369B">L369B</a> ; $38 Address: $369B - end-calc
1 DEFW <A href="#L3686">L3686</a> ; $33 Address: $3686 - jump
1 DEFW <A href="#L367A">L367A</a> ; $35 Address: $367A - dec-jr-nz
1 DEFW <A href="#L3674">L3674</a> ; $1E Address: $3674 - len
1 DEFW <A href="#L3669">L3669</a> ; $1C Address: $3669 - code
1 DEFW <A href="#L3645">L3645</a> ; $1A Address: $3645 - read-in
1 DEFW <A href="#L361F">L361F</a> ; $2E Address: $361F - str$
1 DEFW <A href="#L35DE">L35DE</a> ; $1D Address: $35DE - val
1 DEFW <A href="#L35DE">L35DE</a> ; $18 Address: $35DE - val$
1 DEFW <A href="#L35C9">L35C9</a> ; $2F Address: $35C9 - chrs
1 DEFW <A href="#L359C">L359C</a> ; $17 Address: $359C - strs-add
1 DEFW <A href="#L353B">L353B</a> ; $16 Address: $353B - strs-eql
1 DEFW <A href="#L353B">L353B</a> ; $15 Address: $353B - str-less
1 DEFW <A href="#L353B">L353B</a> ; $14 Address: $353B - str-grtr
1 DEFW <A href="#L353B">L353B</a> ; $13 Address: $353B - strs-neql
1 DEFW <A href="#L353B">L353B</a> ; $12 Address: $353B - str-gr-eql
1 DEFW <A href="#L353B">L353B</a> ; $11 Address: $353B - str-l-eql
1 DEFW <A href="#L353B">L353B</a> ; $0E Address: $353B - nos-eql
1 DEFW <A href="#L353B">L353B</a> ; $0D Address: $353B - no-less
1 DEFW <A href="#L353B">L353B</a> ; $0C Address: $353B - no-grtr
1 DEFW <A href="#L353B">L353B</a> ; $0B Address: $353B - nos-neql
1 DEFW <A href="#L353B">L353B</a> ; $0A Address: $353B - no-gr-eql
1 DEFW <A href="#L353B">L353B</a> ; $09 Address: $353B - no-l-eql
1 DEFW <A href="#L352D">L352D</a> ; $10 Address: $352D - str-&-no
1 DEFW <A href="#L3524">L3524</a> ; $08 Address: $3524 - no-&-no
1 DEFW <A href="#L351B">L351B</a> ; $07 Address: $351B - or
1 DEFW <A href="#L3506">L3506</a> ; $36 Address: $3506 - less-0
1 DEFW <A href="#L3501">L3501</a> ; $30 Address: $3501 - not
1 DEFW <A href="#L34F9">L34F9</a> ; $37 Address: $34F9 - greater-0
1 DEFW <A href="#L34BC">L34BC</a> ; $19 Address: $34BC - usr-$
1 DEFW <A href="#L34B3">L34B3</a> ; $2D Address: $34B3 - usr-no
1 DEFW <A href="#L34AC">L34AC</a> ; $2B Address: $34AC - peek
1 DEFW <A href="#L34A5">L34A5</a> ; $2C Address: $34A5 - in
1 DEFW <A href="#L3492">L3492</a> ; $29 Address: $3492 - sgn
1 DEFW <A href="#L346E">L346E</a> ; $1B Address: $346E - negate
1 DEFW <A href="#L346A">L346A</a> ; $2A Address: $346A - abs
1 DEFW <A href="#L3449">L3449</a> ; Address: $3449 - series-xx $80 - $9F.
1 DEFW <A href="#L343C">L343C</a> ; $01 Address: $343C - exchange
1 DEFW <A href="#L342D">L342D</a> ; Address: $342D - st-mem-xx $C0 - $DF.
1 DEFW <A href="#L341B">L341B</a> ; Address: $341B - stk-const-xx $A0 - $BF.
1 DEFW <A href="#L340F">L340F</a> ; Address: $340F - get-mem-xx $E0 - $FF.
1 DEFW <A href="#L33C6">L33C6</a> ; $34 Address: $33C6 - stk-data
1 DEFW <A href="#L33C0">L33C0</a> ; $31 Address: $33C0 - duplicate
1 DEFW <A href="#L33A2">L33A2</a> ; $3B Address: $33A2 - fp-calc-2
1 DEFW <A href="#L33A1">L33A1</a> ; $02 Address: $33A1 - delete
1 DEFW <A href="#L3297">L3297</a> ; $3D Address: $3297 - re-stack
1 DEFW <A href="#L3214">L3214</a> ; $3A Address: $3214 - truncate
1 DEFW <A href="#L31AF">L31AF</a> ; $05 Address: $31AF - division
1 DEFW <A href="#L30CA">L30CA</a> ; $04 Address: $30CA - multiply
1 DEFW <A href="#L3014">L3014</a> ; $0F Address: $3014 - addition
1 DEFW <A href="#L300F">L300F</a> ; $03 Address: $300F - subtract
1 DEFW <A href="#L2D4F">L2D4F</a> ; $3C Address: $2D4F - e-to-fp
1 DEFW <A href="#L2C02">L2C02</a> ; Address: $2C02; Address: DIM
1 DEFW <A href="#L2382">L2382</a> ; Address: $2382; Address: DRAW
1 DEFW <A href="#L2320">L2320</a> ; Address: $2320; Address: CIRCLE
1 DEFW <A href="#L22DC">L22DC</a> ; Address: $22DC; Address: PLOT
1 DEFW <A href="#L2294">L2294</a> ; Address: $2294; Address: BORDER
1 DEFW <A href="#L2089">L2089</a> ; Address: $2089; Address: INPUT
1 DEFW <A href="#L1FCD">L1FCD</a> ; Address: $1FCD; Address: PRINT
1 DEFW <A href="#L1FC9">L1FC9</a> ; Address: $1FC9; Address: LPRINT
1 DEFW <A href="#L1F60">L1F60</a> ; Address: $1F60; Address: DEF-FN
1 DEFW <A href="#L1F3A">L1F3A</a> ; Address: $1F3A; Address: PAUSE
1 DEFW <A href="#L1F23">L1F23</a> ; Address: $1F23; Address: RETURN
1 DEFW <A href="#L1EED">L1EED</a> ; Address: $1EED; Address: GO-SUB
1 DEFW <A href="#L1EAC">L1EAC</a> ; Address: $1EAC; Address: CLEAR
1 DEFW <A href="#L1EA1">L1EA1</a> ; Address: $1EA1; Address: RUN
1 DEFW <A href="#L1E80">L1E80</a> ; Address: $1E80; Address: POKE
1 DEFW <A href="#L1E7A">L1E7A</a> ; Address: $1E7A; Address: OUT
1 DEFW <A href="#L1E67">L1E67</a> ; Address: $1E67; Address: GO-TO
1 DEFW <A href="#L1E5F">L1E5F</a> ; Address: $1E5F; Address: CONTINUE
1 DEFW <A href="#L1E4F">L1E4F</a> ; Address: $1E4F; Address: RANDOMIZE
1 DEFW <A href="#L1E42">L1E42</a> ; Address: $1E42; Address: RESTORE
1 DEFW <A href="#L1E27">L1E27</a> ; Address: $1E27; Address: DATA
1 DEFW <A href="#L1DED">L1DED</a> ; Address: $1DED; Address: READ
1 DEFW <A href="#L1DAB">L1DAB</a> ; Address: $1DAB; Address: NEXT
1 DEFW <A href="#L1D03">L1D03</a> ; Address: $1D03; Address: FOR
1 DEFW <A href="#L1CF0">L1CF0</a> ; Address: $1CF0; Address: IF
1 DEFW <A href="#L1CEE">L1CEE</a> ; Address: $1CEE; Address: STOP
1 DEFW <A href="#L1BB2">L1BB2</a> ; Address: $1BB2; Address: REM
1 DEFW <A href="#L17F9">L17F9</a> ; Address: $17F9; Address: LIST
1 DEFW <A href="#L17F5">L17F5</a> ; Address: $17F5; Address: LLIST
1 DEFW <A href="#L1736">L1736</a> ; Address: $1736; Address: OPEN
1 DEFW <A href="#L16E5">L16E5</a> ; Address: $16E5; Address: CLOSE
1 DEFW <A href="#L11B7">L11B7</a> ; Address: $11B7; Address: NEW
1 DEFW <A href="#L10A8">L10A8</a> ; KEY-INPUT
1 DEFW <A href="#L0F81">L0F81</a> ; ADD-CHAR
1 DEFW <A href="#L0EAC">L0EAC</a> ; Address: $0EAC; Address: COPY
1 DEFW <A href="#L0D6B">L0D6B</a> ; Address: $0D6B; Address: CLS
1 DEFW <A href="#L03F8">L03F8</a> ; Address: $03F8; Address: BEEP
1 DEFM "scroll"
1 DEFM "Variable not foun"
1 DEFM "VERIF"
1 DEFM "VAL"
1 DEFM "VA"
1 DEFM "US"
1 DEFM "Tape loading erro"
1 DEFM "THE"
1 DEFM "Subscript wron"
1 DEFM "Statement los"
1 DEFM "Start tape, then press any key"
1 DEFM "STR"
1 DEFM "STOP statemen"
1 DEFM "STOP in INPU"
1 DEFM "STO"
1 DEFM "STE"
1 DEFM "SQ"
1 DEFM "SI"
1 DEFM "SG"
1 DEFM "SCREEN"
1 DEFM "SAV"
1 DEFM "RU"
1 DEFM "RN"
1 DEFM "RETURN without GOSU"
1 DEFM "RETUR"
1 DEFM "RESTOR"
1 DEFM "REA"
1 DEFM "RE"
1 DEFM "RANDOMIZ"
1 DEFM "RAMTOP no goo"
1 DEFM "Program:"
1 DEFM "Parameter erro"
1 DEFM "PRIN"
1 DEFM "POK"
1 DEFM "POIN"
1 DEFM "PLO"
1 DEFM "PEE"
1 DEFM "PAUS"
1 DEFM "PAPE"
1 DEFM "Out of scree"
1 DEFM "Out of memor"
1 DEFM "Out of DAT"
1 DEFM "OVE"
1 DEFM "OU"
1 DEFM "OPEN "
1 DEFM "Number too bi"
1 DEFM "Number array:"
1 DEFM "Nonsense in BASI"
1 DEFM "No room for lin"
1 DEFM "NO"
1 DEFM "NEXT without FO"
1 DEFM "NEX"
1 DEFM "NE"
1 DEFM "MOV"
1 DEFM "MERG"
1 DEFM "LPRIN"
1 DEFM "LOA"
1 DEFM "LLIS"
1 DEFM "LIS"
1 DEFM "LIN"
1 DEFM "Invalid strea"
1 DEFM "Invalid file nam"
1 DEFM "Invalid colou"
1 DEFM "Invalid argumen"
1 DEFM "Invalid I/O devic"
1 DEFM "Integer out of rang"
1 DEFM "INVERS"
1 DEFM "INPU"
1 DEFM "INKEY"
1 DEFM "GO T"
1 DEFM "GO SU"
1 DEFM "FORMA"
1 DEFM "FOR without NEX"
1 DEFM "FO"
1 DEFM "FN without DE"
1 DEFM "FLAS"
1 DEFM "End of fil"
1 DEFM "EX"
1 DEFM "ERAS"
1 DEFM "DRA"
1 DEFM "DI"
1 DEFM "DEF F"
1 DEFM "DAT"
1 DEFM "Character array:"
1 DEFM "COP"
1 DEFM "CONTINU"
1 DEFM "COD"
1 DEFM "CO"
1 DEFM "CLOSE "
1 DEFM "CLEA"
1 DEFM "CL"
1 DEFM "CIRCL"
1 DEFM "CHR"
1 DEFM "CA"
1 DEFM "Bytes:"
1 DEFM "BRIGH"
1 DEFM "BREAK into progra"
1 DEFM "BREAK - CONT repeat"
1 DEFM "BORDE"
1 DEFM "BI"
1 DEFM "BEE"
1 DEFM "ATT"
1 DEFM "AT"
1 DEFM "AS"
1 DEFM "AN"
1 DEFM "AC"
1 DEFM "AB"
1 DEFM " 1982 Sinclair Research Lt"
1 DEFB <A href="#L1CDB">L1CDB</a> - $ ; CF offset to Address: CLASS-0B
1 DEFB <A href="#L1CBE">L1CBE</a> - $ ; B4 offset to Address: CLASS-09
1 DEFB <A href="#L1C96">L1C96</a> - $ ; 8E offset to Address: CLASS-07
1 DEFB <A href="#L1C8C">L1C8C</a> - $ ; 81 offset to Address: CLASS-0A
1 DEFB <A href="#L1C82">L1C82</a> - $ ; 7B offset to Address: CLASS-06
1 DEFB <A href="#L1C7A">L1C7A</a> - $ ; 71 offset to Address: CLASS-08
1 DEFB <A href="#L1C6C">L1C6C</a> - $ ; 67 offset to Address: CLASS-04
1 DEFB <A href="#L1C4E">L1C4E</a> - $ ; 4B offset to Address: CLASS-02
1 DEFB <A href="#L1C1F">L1C1F</a> - $ ; 1D offset to Address: CLASS-01
1 DEFB <A href="#L1C11">L1C11</a> - $ ; 0B offset to Address: CLASS-05
1 DEFB <A href="#L1C0D">L1C0D</a> - $ ; 09 offset to Address: CLASS-03
1 DEFB <A href="#L1B14">L1B14</a> - $ ; CB offset to Address: P-CAT
1 DEFB <A href="#L1B10">L1B10</a> - $ ; C4 offset to Address: P-ERASE
1 DEFB <A href="#L1B0A">L1B0A</a> - $ ; BF offset to Address: P-MOVE
1 DEFB <A href="#L1B06">L1B06</a> - $ ; BC offset to Address: P-FORMAT
1 DEFB <A href="#L1B02">L1B02</a> - $ ; B4 offset to Address: P-CLOSE
1 DEFB <A href="#L1AFC">L1AFC</a> - $ ; AF offset to Address: P-OPEN
1 DEFB <A href="#L1AF5">L1AF5</a> - $ ; 94 offset to Address: P-BORDER
1 DEFB <A href="#L1AF1">L1AF1</a> - $ ; 98 offset to Address: P-OUT
1 DEFB <A href="#L1AF0">L1AF0</a> - $ ; 98 offset to Address: P-OVER
1 DEFB <A href="#L1AEF">L1AEF</a> - $ ; 98 offset to Address: P-INVERSE
1 DEFB <A href="#L1AEE">L1AEE</a> - $ ; 98 offset to Address: P-BRIGHT
1 DEFB <A href="#L1AED">L1AED</a> - $ ; 98 offset to Address: P-FLASH
1 DEFB <A href="#L1AEC">L1AEC</a> - $ ; 98 offset to Address: P-PAPER
1 DEFB <A href="#L1AEB">L1AEB</a> - $ ; 98 offset to Address: P-INK
1 DEFB <A href="#L1AE7">L1AE7</a> - $ ; 95 offset to Address: P-CIRCLE
1 DEFB <A href="#L1AE3">L1AE3</a> - $ ; 92 offset to Address: P-BEEP
1 DEFB <A href="#L1AE2">L1AE2</a> - $ ; 93 offset to Address: P-MERGE
1 DEFB <A href="#L1AE1">L1AE1</a> - $ ; 91 offset to Address: P-VERIFY
1 DEFB <A href="#L1AE0">L1AE0</a> - $ ; 77 offset to Address: P-LOAD
1 DEFB <A href="#L1ADF">L1ADF</a> - $ ; 6D offset to Address: P-SAVE
1 DEFB <A href="#L1ADC">L1ADC</a> - $ ; 81 offset to Address: P-LLIST
1 DEFB <A href="#L1AD9">L1AD9</a> - $ ; 7F offset to Address: P-LPRINT
1 DEFB <A href="#L1AD6">L1AD6</a> - $ ; 5D offset to Address: P-COPY
1 DEFB <A href="#L1AD2">L1AD2</a> - $ ; 5C offset to Address: P-DRAW
1 DEFB <A href="#L1ACF">L1ACF</a> - $ ; 70 offset to Address: P-RESTORE
1 DEFB <A href="#L1ACC">L1ACC</a> - $ ; 6E offset to Address: P-DATA
1 DEFB <A href="#L1AC9">L1AC9</a> - $ ; 6C offset to Address: P-READ
1 DEFB <A href="#L1AC5">L1AC5</a> - $ ; 59 offset to Address: P-PAUSE
1 DEFB <A href="#L1AC1">L1AC1</a> - $ ; 51 offset to Address: P-PLOT
1 DEFB <A href="#L1ABE">L1ABE</a> - $ ; 49 offset to Address: P-CLS
1 DEFB <A href="#L1ABB">L1ABB</a> - $ ; 44 offset to Address: P-CLEAR
1 DEFB <A href="#L1AB8">L1AB8</a> - $ ; 56 offset to Address: P-CONT
1 DEFB <A href="#L1AB5">L1AB5</a> - $ ; 42 offset to Address: P-RANDOM
1 DEFB <A href="#L1AB1">L1AB1</a> - $ ; 43 offset to Address: P-POKE
1 DEFB <A href="#L1AAE">L1AAE</a> - $ ; 44 offset to Address: P-LIST
1 DEFB <A href="#L1AAB">L1AAB</a> - $ ; 3A offset to Address: P-RUN
1 DEFB <A href="#L1AA8">L1AA8</a> - $ ; 48 offset to Address: P-NEW
1 DEFB <A href="#L1AA5">L1AA5</a> - $ ; 41 offset to Address: P-REM
1 DEFB <A href="#L1AA2">L1AA2</a> - $ ; 3F offset to Address: P-DIM
1 DEFB <A href="#L1A9F">L1A9F</a> - $ ; 37 offset to Address: P-INPUT
1 DEFB <A href="#L1A9C">L1A9C</a> - $ ; 2D offset to Address: P-PRINT
1 DEFB <A href="#L1A98">L1A98</a> - $ ; 2B offset to Address: P-NEXT
1 DEFB <A href="#L1A90">L1A90</a> - $ ; 2B offset to Address: P-FOR
1 DEFB <A href="#L1A8D">L1A8D</a> - $ ; 15 offset to Address: P-RETURN
1 DEFB <A href="#L1A8A">L1A8A</a> - $ ; 2E offset to Address: P-STOP
1 DEFB <A href="#L1A86">L1A86</a> - $ ; 1F offset to Address: P-GO-SUB
1 DEFB <A href="#L1A81">L1A81</a> - $ ; 0D offset to Address: P-IF
1 DEFB <A href="#L1A7D">L1A7D</a> - $ ; 17 offset to Address: P-GO-TO
1 DEFB <A href="#L1A7A">L1A7A</a> - $ ; 0F offset to Address: P-LET
1 DEFB <A href="#L107C">L107C</a> - $ ; 15d offset $D4 to Address: ED-GRAPH
1 DEFB <A href="#L1076">L1076</a> - $ ; 14d offset $CF to Address: ED-SYMBOL
1 DEFB <A href="#L1059">L1059</a> - $ ; 11d offset $B5 to Address: ED-UP
1 DEFB <A href="#L1024">L1024</a> - $ ; 13d offset $7E to Address: ED-ENTER
1 DEFB <A href="#L1015">L1015</a> - $ ; 12d offset $70 to Address: ED-DELETE
1 DEFB <A href="#L100C">L100C</a> - $ ; 09d offset $6A to Address: ED-RIGHT