; Last updated: 13-DEC-2004 ; 2011 Updated to remove -, +, /, *, &, ; characters from labels (which confuse assemblers) ; ; 2011 Updated for conditional assembly of ORIGINAL or "Shoulders of Giants" ROM ; ; 2014-08-01 Updated to add CHARS_PER_LINE_WINDOW which is normally 32. ; ; The ideal pixel rates for square pixels on a PAL system are ; 14.75 MHz (interlaced) and ; 7.375 MHz (non-interlaced, which the ZX80/ZX81 are). ; These are not commonly available but fortunately one can buy ; baud-rate generator frequencies such as ; 14.7456 and 7.3728 MHz that are only 0.03% low ; which is more than close enough. ; ; ZX video normally has 6.5 MHz pixel rate, ; so 32 characters take 256 pixels in 39.4 microseconds. ; A 7.3728 MHz clock and 40 characters produces ; 320 pixels in 43.4 microseconds. ; ; ZX80 video generation is software defined so it is ; easy to get square pixels simply by subtracting 8 from the bytes ; at hex addresses 287, 2AA and 2B8. ; The video will appear to the left of the screen but ; the characters will be square and a diagonal graphic line ; will be at 45 degrees. ; ; ZX81 video generation in fast mode exactly the same as the ZX80. ; ; ZX81 video generation in slow mode is problematic, in that ; the NMI generator expects a 3.25 MHz CPU clock ; (3.25MHz / 208 = 15.625 kHz = 64 microsecond line period) ; It is inside the ULA where it cannot be modified. ; ; Simply fitting a 7.3728 MHz crystal would reduce the line period to ; 57.3 microseconds. Slow mode would require the CPU clock to be ; divided by 236. ; ; Square pixels on NTSC requires 11+3/11 = 11.272... MHz (interlaced) ; or 5.63.. non-interlaced which is slower than the original 6.5 MHz. ; The NTSC line period is still 64 microseconds, so 256 pixels ; stretch over 45 microseconds, and 320 pixels over 56 microseconds. ; Thus it is possible to get square pixels on an NTSC display, ; it is not possible to get 40 column text as well. ; That would require the PAL clock, but pixels would not be square. ; ; The ZX printer is fixed in hardware. ; It will not work in 40-column mode. ; ; ; ; PIXEL_CLOCK equ 7372500 ; ; on-line assembler complains about the line above ; ; CHARS_PER_LINE_WINDOW always 32 for 6.5 MHz pixel rate ; always 40 for 7.375 MHz PAL square pixel rate ; CHARS_PER_LINE_WINDOW equ 40 ; 32 originally ; ; CHARS_PER_LINE always 32 for 6.5 MHz pixel rate ; but 32 or 40 if using PAL square pixel rate ; CHARS_HORIZONTAL equ 40 ; 32 originally CHARS_VERTICAL equ 24 ; ; 2014-08-01 ; Largely working but some bugs remain. ; Working: ; You can type text and it takes 40 characters before new line. ; 40 characters are nicely centred in the screen. ; PLOT X,Y accepts X from 0 to 79. ; Faulty: ; System crashing in an authentic ZX81 fashion, ; I don't know if this is due to software bugs ; or socket joint disturbance from key presses. ; ; ; 2018-01-09 add org ; Assembles using on-line assembler "zasm" at: ; ; http://k1.spdns.de/cgi-bin/zasm.cgi ; org 0 FALSE equ 0 ORIGINAL equ 0 NOT_BODGED equ 1 ; 2018-02-09 CHARS_HORIZONTAL placed in SCROLL routine. ; Thanks to Adam Klotblixt for testing code and spotting this bug. ; Also added to some G007 routines. ;
; ; Work in progress. ; This file will cross-assemble an original version of the "Improved" ; ZX81 ROM. ; The file can be modified to change the behaviour of the ROM ; when used in emulators although there is no spare space available. ; ; The documentation is incomplete and if you can find a copy ; of "The Complete Spectrum ROM Disassembly" then many routines ; such as POINTERS and most of the mathematical routines are ; similar and often identical. ; ; I've used the labels from the above book in this file and also ; some from the more elusive Complete ZX81 ROM Disassembly ; by the same publishers, Melbourne House. #if 0 ; zasm does not understand these: #define DEFB .BYTE ; TASM cross-assembler definitions #define DEFW .WORD #define EQU .EQU #endif ; define stuff sensibly: ; ; I/O locations: ; IO_PORT_TAPE equ $FF ; write IO_PORT_SCREEN equ $FF ; write IO_PORT_KEYBOARD_RD equ $FE ; A0 low IO_PORT_NMI_GEN_ON equ $FE ; A0 low IO_PORT_NMI_GEN_OFF equ $FD ; A1 low IO_PORT_PRINTER equ $FB ; A2 low
; ; System variables: ; RAMBASE equ $4000 ERR_NR equ $4000 ; The report code. Incremented before printing. FLAGS equ $4001 ; Bit 0: Suppression of leading space. ; Bit 1: Control Flag for the printer. ; Bit 2: Selects K or F mode; or, F or G ; Bit 6: FP no. or string parameters. ; Bit 7: Reset during syntax checking." ERR_SP equ $4002 ; Pointer to the GOSUB stack. RAMTOP equ $4004 ; The top of available RAM, or as specified. MODE equ $4006 ; Holds the code for K or F PPC equ $4007 ; Line number of the current statement. PPC_hi equ PPC+1 VERSN equ $4009 ; Marks the start of the RAM that is saved. E_PPC equ $400A ; The BASIC line with the cursor D_FILE equ $400C ; Pointer to Display file DF_CC equ $400E ; Address for PRINT AT position VARS equ $4010 ; Pointer to variable area DEST equ $4012 ; Address of current variable in program area E_LINE equ $4014 ; Pointer to workspace E_LINE_hi equ E_LINE+1 CH_ADD equ $4016 ; Pointer for scanning a line, in program or workspace X_PTR equ $4018 ; Pointer to syntax error. X_PTR_lo equ X_PTR X_PTR_hi equ X_PTR+1 STKBOT equ $401A ; Pointer to calculator stack bottom. STKEND equ $401C ; Pointer to calculator stack end. BERG equ $401E ; Used for many different counting purposes MEM equ $401F ; Pointer to base of table of fp. nos, either in calc. stack or variable area. ; ; Unused by ZX BASIC. Or FLAG Y for G007 DF_SZ equ $4022 ; Number of lines in the lower screen S_TOP equ $4023 ; Current line number of automatic listing LAST_K equ $4025 ; Last Key pressed DEBOUNCE_VAR equ $4027 ; The de-bounce status MARGIN equ $4028 ; Adjusts for differing TV standards NXTLIN equ $4029 ; Next BASIC line to be interpreted OLDPPC equ $402B ; Last line number, in case needed. FLAGX equ $402D ; Bit 0: Reset indicates an arrayed variable ; Bit 1: Reset indicates a given variable exists ; Bit 5: Set during INPUT mode ; Bit 7: Set when INPUT is to be numeric STRLEN equ $402E ; Length of a string, or a BASIC line STRLEN_lo equ STRLEN ; T_ADDR equ $4030 ; Pointer to parameter table. & distinguishes between PLOT & UNPLOT SEED equ $4032 ; For RANDOM function FRAMES equ $4034 ; Frame counter FRAMES_hi equ FRAMES+1 ; COORDS equ $4036 ; X & Y for PLOT COORDS_x equ COORDS ; PR_CC equ $4038 ; Print buffer counter S_POSN equ $4039 ; Line & Column for PRINT AT S_POSN_x equ $4039 ; S_POSN_y equ $403A ; CDFLAG equ $403B ; Bit 6 = the true fast/slow flag ; Bit 7 = copy of the fast/slow flag. RESET when FAST needed PRBUFF equ $403C ; Printer buffer PRBUFF_END equ $405C ; MEM_0_1st equ $405D ; room for 5 floating point numbers (meme_0 to mem_ 5???) ; $407B ; unused. Or RESTART to G007 ; $407D ; The BASIC program starts here ; equ $40 ; equ $40 ; equ $40 ; First byte after system variables: USER_RAM equ $407D MAX_RAM equ $7FFF
;=============================== ; ZX81 constants: ;=============================== ; ZX characters (not the same as ASCII) ;------------------------------- ZX_SPACE equ $00 ; ZX_graphic equ $01
; ZX_graphic equ $02 
; ZX_graphic equ $03 
; ZX_graphic equ $04 
; ZX_graphic equ $05 
; ZX_graphic equ $06 
; ZX_graphic equ $07 
; ZX_graphic equ $08 
; ZX_graphic equ $09 
; ZX_graphic equ $0A 
ZX_QUOTE equ $0B
ZX_POUND equ $0C
ZX_DOLLAR equ $0D
ZX_COLON equ $0E
ZX_QUERY equ $0F
ZX_BRACKET_LEFT equ $10
ZX_BRACKET_RIGHT equ $11
ZX_GREATER_THAN equ $12
ZX_LESS_THAN equ $13
ZX_EQUAL equ $14
ZX_PLUS equ $15
ZX_MINUS equ $16
ZX_STAR equ $17
ZX_SLASH equ $18
ZX_SEMICOLON equ $19
ZX_COMMA equ $1A
ZX_PERIOD equ $1B
ZX_0 equ $1C
ZX_1 equ $1D
ZX_2 equ $1E
ZX_3 equ $1F
ZX_4 equ $20
ZX_5 equ $21
ZX_6 equ $22
ZX_7 equ $23
ZX_8 equ $24
ZX_9 equ $25
ZX_A equ $26
ZX_B equ $27
ZX_C equ $28
ZX_D equ $29
ZX_E equ $2A
ZX_F equ $2B
ZX_G equ $2C
ZX_H equ $2D
ZX_I equ $2E
ZX_J equ $2F
ZX_K equ $30
ZX_L equ $31
ZX_M equ $32
ZX_N equ $33
ZX_O equ $34
ZX_P equ $35
ZX_Q equ $36
ZX_R equ $37
ZX_S equ $38
ZX_T equ $39
ZX_U equ $3A
ZX_V equ $3B
ZX_W equ $3C
ZX_X equ $3D
ZX_Y equ $3E
ZX_Z equ $3F
ZX_RND equ $40
ZX_INKEY_STR equ $41
ZX_PI equ $42
;
; $43 to $6F not used
;
ZX_cursor_up equ $70
ZX_cursor_down equ $71
ZX_cursor_left equ $72
ZX_cursor_right equ $73
ZX_GRAPHICS equ $74
ZX_EDIT equ $75
ZX_NEWLINE equ $76
ZX_RUBOUT equ $77
ZX_KL equ $78
ZX_FUNCTION equ $79
;
; $7A to $7F not used
;
ZX_CURSOR equ $7F
;
; $80 to $BF are inverses of $00 to $3F
;
; ZX_graphic equ $80 
; inverse space
; ZX_graphic equ $81 
; ZX_graphic equ $82 
; ZX_graphic equ $83 
; ZX_graphic equ $84 
; ZX_graphic equ $85 
; ZX_graphic equ $86 
; ZX_graphic equ $87 
; ZX_graphic equ $88 
; ZX_graphic equ $89 
; ZX_graphic equ $8A 
ZX_INV_QUOTE equ $8B
ZX_INV_POUND equ $8C
ZX_INV_DOLLAR equ $8D
ZX_INV_COLON equ $8E
ZX_INV_QUERY equ $8F
ZX_INV_BRACKET_RIGHT equ $90
ZX_INV_BRACKET_LEFT equ $91
ZX_INV_GT equ $92
ZX_INV_PLUS equ $95
ZX_INV_MINUS equ $96
ZX_INV_K equ $B0
ZX_INV_S equ $B8
ZX_DOUBLE_QUOTE equ $C0
ZX_AT equ $C1
ZX_TAB equ $C2
; not used equ $C3
ZX_CODE equ $C4
ZX_VAL equ $C5
ZX_LEN equ $C6
ZX_SIN equ $C7
ZX_COS equ $C8
ZX_TAN equ $C9
ZX_ASN equ $CA
ZX_ACS equ $CB
ZX_ATN equ $CC
ZX_LN equ $CD
ZX_EXP equ $CE
ZX_INT equ $CF
ZX_SQR equ $D0
ZX_SGN equ $D1
ZX_ABS equ $D2
ZX_PEEK equ $D3
ZX_USR equ $D4
ZX_STR_STR equ $D5 ; STR$
ZX_CHR_STR equ $D6 ; CHR$
ZX_NOT equ $D7
ZX_POWER equ $D8
ZX_OR equ $D9
ZX_AND equ $DA
ZX_LESS_OR_EQUAL equ $DB
ZX_GREATER_OR_EQUAL equ $DC
ZX_NOT_EQUAL equ $DD
ZX_THEN equ $DE
ZX_TO equ $DF
ZX_STEP equ $E0
ZX_LPRINT equ $E1
ZX_LLIST equ $E2
ZX_STOP equ $E3
ZX_SLOW equ $E4
ZX_FAST equ $E5
ZX_NEW equ $E6
ZX_SCROLL equ $E7
ZX_CONT equ $E8
ZX_DIM equ $E9
ZX_REM equ $EA
ZX_FOR equ $EB
ZX_GOTO equ $EC
ZX_GOSUB equ $ED
ZX_INPUT equ $EE
ZX_LOAD equ $EF
ZX_LIST equ $F0
ZX_LET equ $F1
ZX_PAUSE equ $F2
ZX_NEXT equ $F3
ZX_POKE equ $F4
ZX_PRINT equ $F5
ZX_PLOT equ $F6
ZX_RUN equ $F7
ZX_SAVE equ $F8
ZX_RAND equ $F9
ZX_IF equ $FA
ZX_CLS equ $FB
ZX_UNPLOT equ $FC
ZX_CLEAR equ $FD
ZX_RETURN equ $FE
ZX_COPY equ $FF
; _CLASS_00 equ 0 _CLASS_01 equ 1 _CLASS_02 equ 2 _CLASS_03 equ 3 _CLASS_04 equ 4 _CLASS_05 equ 5 _CLASS_06 equ 6
; These values taken from BASIC manual ; ; ERROR_CODE_SUCCESS equ 0 ERROR_CODE_CONTROL_VARIABLE equ 1 ERROR_CODE_UNDEFINED_VARIABLE equ 2 ERROR_CODE_SUBSCRIPT_OUT_OF_RANGE equ 3 ERROR_CODE_NOT_ENOUGH_MEMORY equ 4 ERROR_CODE_NO_ROOM_ON_SCREEN equ 5 ERROR_CODE_ARITHMETIC_OVERFLOW equ 6 ERROR_CODE_RETURN_WITHOUT_GOSUB equ 7 ERROR_CODE_INPUT_AS_A_COMMAND equ 8 ERROR_CODE_STOP equ 9 ERROR_CODE_INVALID_ARGUMENT equ 10 ERROR_CODE_INTEGER_OUT_OF_RANGE equ 11 ERROR_CODE_VAL_STRING_INVALID equ 12 ERROR_CODE_BREAK equ 13 ERROR_CODE_EMPTY_PROGRAM_NAME equ 15
; ; codes for Forth-like calculator ; __jump_true equ $00 __exchange equ $01 __delete equ $02 __subtract equ $03 __multiply equ $04 __division equ $05 __to_power equ $06 __or equ $07 __boolean_num_and_num equ $08 __num_l_eql equ $09 __num_gr_eql equ $0A __nums_neql equ $0B __num_grtr equ $0C __num_less equ $0D __nums_eql equ $0E __addition equ $0F __strs_and_num equ $10 __str_l_eql equ $11 __str_gr_eql equ $12 __strs_neql equ $13 __str_grtr equ $14 __str_less equ $15 __strs_eql equ $16 __strs_add equ $17 __negate equ $18 __code equ $19 __val equ $1A __len equ $1B __sin equ $1C __cos equ $1D __tan equ $1E __asn equ $1F __acs equ $20 __atn equ $21 __ln equ $22 __exp equ $23 __int equ $24 __sqr equ $25 __sgn equ $26 __abs equ $27 __peek equ $28 __usr_num equ $29 __str_dollar equ $2A __chr_dollar equ $2B __not equ $2C __duplicate equ $2D __n_mod_m equ $2E __jump equ $2F __stk_data equ $30 __dec_jr_nz equ $31 __less_0 equ $32 __greater_0 equ $33 __end_calc equ $34 __get_argt equ $35 __truncate equ $36 __fp_calc_2 equ $37 __e_to_fp equ $38 ; ; __series_xx equ $39 : $80__$9F. ; tells the stack machine to push ; 0 to 31 floating-point values on the stack. ; __series_06 equ $86 __series_08 equ $88 __series_0C equ $8C ; __stk_const_xx equ $3A : $A0__$BF. ; __st_mem_xx equ $3B : $C0__$DF. ; __get_mem_xx equ $3C : $E0__$FF. __st_mem_0 equ $C0 __st_mem_1 equ $C1 __st_mem_2 equ $C2 __st_mem_3 equ $C3 __st_mem_4 equ $C4 __st_mem_5 equ $C5 __st_mem_6 equ $C6 __st_mem_7 equ $C7 __get_mem_0 equ $E0 __get_mem_1 equ $E1 __get_mem_2 equ $E2 __get_mem_3 equ $E3 __get_mem_4 equ $E4 __stk_zero equ $A0 __stk_one equ $A1 __stk_half equ $A2 __stk_half_pi equ $A3 __stk_ten equ $A4
;***************************************** ;** Part 1. RESTART ROUTINES AND TABLES ** ;*****************************************
; THE 'START'
; All Z80 chips start at location zero. ; At start-up the Interrupt Mode is 0, ZX computers use Interrupt Mode 1. ; Interrupts are disabled . mark_0000: START: OUT (IO_PORT_NMI_GEN_OFF),A ; Turn off the NMI generator if this ROM is ; running in ZX81 hardware. This does nothing ; if this ROM is running within an upgraded ; ZX80. LD BC,MAX_RAM ; Set BC to the top of possible RAM. ; The higher unpopulated addresses are used for ; video generation. JP RAM_CHECK ; Jump forward to RAM_CHECK.
; THE 'ERROR' RESTART
; The error restart deals immediately with an error. ; ZX computers execute the same code in runtime as when checking syntax. ; If the error occurred while running a program ; then a brief report is produced. ; If the error occurred while entering a BASIC line or in input etc., ; then the error marker indicates the exact point at which the error lies. mark_0008: ERROR_1: LD HL,(CH_ADD) ; fetch character address from CH_ADD. LD (X_PTR),HL ; and set the error pointer X_PTR. JR ERROR_2 ; forward to continue at ERROR_2.
; THE 'PRINT A CHARACTER' RESTART
; This restart prints the character in the accumulator using the alternate ; register set so there is no requirement to save the main registers. ; There is sufficient room available to separate a space (zero) from other ; characters as leading spaces need not be considered with a space. mark_0010: PRINT_A: AND A ; test for zero - space. JP NZ,PRINT_CH ; jump forward if not to PRINT_CH. JP PRINT_SP ; jump forward to PRINT_SP. ; ___ #if ORIGINAL DEFB $FF ; unused location. #else DEFB $01 ;+ unused location. Version. PRINT PEEK 23 #endif
; THE 'COLLECT A CHARACTER' RESTART
; The character addressed by the system variable CH_ADD is fetched and if it ; is a non-space, non-cursor character it is returned else CH_ADD is ; incremented and the new addressed character tested until it is not a space. mark_0018: GET_CHAR: LD HL,(CH_ADD) ; set HL to character address CH_ADD. LD A,(HL) ; fetch addressed character to A. TEST_SP: AND A ; test for space. RET NZ ; return if not a space NOP ; else trickle through NOP ; to the next routine.
; THE 'COLLECT NEXT CHARACTER' RESTART
; The character address is incremented and the new addressed character is ; returned if not a space, or cursor, else the process is repeated. mark_0020: NEXT_CHAR: CALL CH_ADD_PLUS_1 ; gets next immediate ; character. JR TEST_SP ; back ; ___ DEFB $FF, $FF, $FF ; unused locations.
; THE 'FLOATING POINT CALCULATOR' RESTART
; this restart jumps to the recursive floating-point calculator. ; the ZX81's internal, FORTH-like, stack-based language. ; ; In the five remaining bytes there is, appropriately, enough room for the ; end-calc literal - the instruction which exits the calculator. mark_0028: FP_CALC: #if ORIGINAL JP CALCULATE ; jump immediately to the CALCULATE routine. #else JP CALCULATE ;+ jump to the NEW calculate routine address. #endif mark_002B: end_calc: POP AF ; drop the calculator return address RE_ENTRY EXX ; switch to the other set. EX (SP),HL ; transfer H'L' to machine stack for the ; return address. ; when exiting recursion then the previous ; pointer is transferred to H'L'. EXX ; back to main set. RET ; return.
; THE 'MAKE BC SPACES' RESTART
; This restart is used eight times to create, in workspace, the number of ; spaces passed in the BC register. mark_0030: BC_SPACES: PUSH BC ; push number of spaces on stack. LD HL,(E_LINE) ; fetch edit line location from E_LINE. PUSH HL ; save this value on stack. JP RESERVE ; jump forward to continue at RESERVE.
_START equ $00 _ERROR_1 equ $08 _PRINT_A equ $10 _GET_CHAR equ $18 _NEXT_CHAR equ $20 _FP_CALC equ $28 _BC_SPACES equ $30
; THE 'INTERRUPT' RESTART
; The Mode 1 Interrupt routine is concerned solely with generating the central ; television picture. ; On the ZX81 interrupts are enabled only during the interrupt routine, ; although the interrupt ; ; This Interrupt Service Routine automatically disables interrupts at the ; outset and the last interrupt in a cascade exits before the interrupts are ; enabled. ; ; There is no DI instruction in the ZX81 ROM. ; ; A maskable interrupt is triggered when bit 6 of the Z80's Refresh register ; changes from set to reset. ; ; The Z80 will always be executing a HALT (NEWLINE) when the interrupt occurs. ; A HALT instruction repeatedly executes NOPS but the seven lower bits ; of the Refresh register are incremented each time as they are when any ; simple instruction is executed. (The lower 7 bits are incremented twice for ; a prefixed instruction) ; ; This is controlled by the Sinclair Computer Logic Chip - manufactured from ; a Ferranti Uncommitted Logic Array. ; ; When a Mode 1 Interrupt occurs the Program Counter, which is the address in ; the upper echo display following the NEWLINE/HALT instruction, goes on the ; machine stack. 193 interrupts are required to generate the last part of ; the 56th border line and then the 192 lines of the central TV picture and, ; although each interrupt interrupts the previous one, there are no stack ; problems as the 'return address' is discarded each time. ; ; The scan line counter in C counts down from 8 to 1 within the generation of ; each text line. For the first interrupt in a cascade the initial value of ; C is set to 1 for the last border line. ; Timing is of the utmost importance as the RH border, horizontal retrace ; and LH border are mostly generated in the 58 clock cycles this routine ; takes .
MARK_0038: INTERRUPT: DEC C ; (4) decrement C - the scan line counter. JP NZ,SCAN_LINE ; (10/10) JUMP forward if not zero to SCAN_LINE POP HL ; (10) point to start of next row in display ; file. DEC B ; (4) decrement the row counter. (4) RET Z ; (11/5) return when picture complete to R_IX_1_LAST_NEWLINE ; with interrupts disabled. SET 3,C ; (8) Load the scan line counter with eight. ; Note. LD C,$08 is 7 clock cycles which ; is way too fast. ; -> mark_0041: WAIT_INT: ; ; NB $DD is for 32-column display ; LD R,A ; (9) Load R with initial rising value $DD. EI ; (4) Enable Interrupts. [ R is now $DE ]. JP (HL) ; (4) jump to the echo display file in upper ; memory and execute characters $00 - $3F ; as NOP instructions. The video hardware ; is able to read these characters and, ; with the I register is able to convert ; the character bitmaps in this ROM into a ; line of bytes. Eventually the NEWLINE/HALT ; will be encountered before R reaches $FF. ; It is however the transition from $FF to ; $80 that triggers the next interrupt. ; [ The Refresh register is now $DF ] ; ___ mark_0045: SCAN_LINE: POP DE ; (10) discard the address after NEWLINE as the ; same text line has to be done again ; eight times. RET Z ; (5) Harmless Nonsensical Timing. ; (condition never met) JR WAIT_INT ; (12) back to WAIT_INT ; Note. that a computer with less than 4K or RAM will have a collapsed ; display file and the above mechanism deals with both types of display. ; ; With a full display, the 32 characters in the line are treated as NOPS ; and the Refresh register rises from $E0 to $FF and, at the next instruction ; - HALT, the interrupt occurs. ; With a collapsed display and an initial NEWLINE/HALT, it is the NOPs ; generated by the HALT that cause the Refresh value to rise from $E0 to $FF, ; triggering an Interrupt on the next transition. ; This works happily for all display lines between these extremes and the ; generation of the 32 character, 1 pixel high, line will always take 128 ; clock cycles.
; THE 'INCREMENT CH_ADD' SUBROUTINE
; This is the subroutine that increments the character address system variable ; and returns if it is not the cursor character. The ZX81 has an actual ; character at the cursor position rather than a pointer system variable ; as is the case with prior and subsequent ZX computers. mark_0049: CH_ADD_PLUS_1: LD HL,(CH_ADD) ; fetch character address to CH_ADD. mark_004C: TEMP_PTR1: INC HL ; address next immediate location. mark_004D: TEMP_PTR2: LD (CH_ADD),HL ; update system variable CH_ADD. LD A,(HL) ; fetch the character. CP ZX_CURSOR ; compare to cursor character. RET NZ ; return if not the cursor. JR TEMP_PTR1 ; back for next character to TEMP_PTR1.
; THE 'ERROR_2' BRANCH
; This is a continuation of the error restart. ; If the error occurred in runtime then the error stack pointer will probably ; lead to an error report being printed unless it occurred during input. ; If the error occurred when checking syntax then the error stack pointer ; will be an editing routine and the position of the error will be shown ; when the lower screen is reprinted. mark_0056: ERROR_2: POP HL ; pop the return address which points to the ; DEFB, error code, after the RST 08. LD L,(HL) ; load L with the error code. HL is not needed ; anymore. mark_0058: ERROR_3: LD (IY+ERR_NR-RAMBASE),L ; place error code in system variable ERR_NR LD SP,(ERR_SP) ; set the stack pointer from ERR_SP CALL SLOW_FAST ; selects slow mode. JP SET_MIN ; exit to address on stack via routine SET_MIN. ; ___ DEFB $FF ; unused.
; THE 'NON MASKABLE INTERRUPT' ROUTINE
; Jim Westwood's technical dodge using Non-Maskable Interrupts solved the ; flicker problem of the ZX80 and gave the ZX81 a multi-tasking SLOW mode ; with a steady display. Note that the AF' register is reserved for this ; function and its interaction with the display routines. When counting ; TV lines, the NMI makes no use of the main registers. ; The circuitry for the NMI generator is contained within the SCL (Sinclair ; Computer Logic) chip. ; ( It takes 32 clock cycles while incrementing towards zero ). mark_0066: NMI: EX AF,AF' ; (4) switch in the NMI's copy of the ; accumulator. INC A ; (4) increment. JP M,NMI_RET ; (10/10) jump, if minus, to NMI_RET as this is ; part of a test to see if the NMI ; generation is working or an intermediate ; value for the ascending negated blank ; line counter. JR Z,NMI_CONT ; (12) forward to NMI_CONT ; when line count has incremented to zero. ; Note. the synchronizing NMI when A increments from zero to one takes this ; 7 clock cycle route making 39 clock cycles in all. mark_006D: NMI_RET: EX AF,AF' ; (4) switch out the incremented line counter ; or test result $80 RET ; (10) return to User application for a while. ; ___ ; This branch is taken when the 55 (or 31) lines have been drawn. mark_006F: NMI_CONT: EX AF,AF' ; (4) restore the main accumulator. PUSH AF ; (11) * Save Main Registers PUSH BC ; (11) ** PUSH DE ; (11) *** PUSH HL ; (11) **** ; the next set-up procedure is only really applicable when the top set of ; blank lines have been generated. LD HL,(D_FILE) ; (16) fetch start of Display File from D_FILE ; points to the HALT at beginning. SET 7,H ; (8) point to upper 32K 'echo display file' HALT ; (1) HALT synchronizes with NMI. ; Used with special hardware connected to the ; Z80 HALT and WAIT lines to take 1 clock cycle.
; the NMI has been generated - start counting. ; The cathode ray is at the RH side of the TV. ; ; First the NMI servicing, similar to CALL = 17 clock cycles. ; Then the time taken by the NMI for zero-to-one path = 39 cycles ; The HALT above = 01 cycles. ; The two instructions below = 19 cycles. ; The code at R_IX_1 up to and including the CALL = 43 cycles. ; The Called routine at DISPLAY_5 = 24 cycles. ; -------------------------------------- --- ; Total Z80 instructions = 143 cycles. ; ; Meanwhile in TV world, ; Horizontal retrace = 15 cycles. ; Left blanking border 8 character positions = 32 cycles ; Generation of 75% scanline from the first NEWLINE = 96 cycles ; --------------------------------------- --- ; = 143 cycles ; ; Since at the time the first JP (HL) is encountered to execute the echo ; display another 8 character positions have to be put out, then the ; Refresh register need to hold $F8. Working back and counteracting ; the fact that every instruction increments the Refresh register then ; the value that is loaded into R needs to be $F5. :-) ; ; OUT (IO_PORT_NMI_GEN_OFF),A ; (11) Stop the NMI generator. JP (IX) ; (8) forward to R_IX_1 (after top) or R_IX_2 ; **************** ; ** KEY TABLES ** ; ****************
; THE 'UNSHIFTED' CHARACTER CODES
mark_007E: K_UNSHIFT: DEFB ZX_Z DEFB ZX_X DEFB ZX_C DEFB ZX_V DEFB ZX_A DEFB ZX_S DEFB ZX_D DEFB ZX_F DEFB ZX_G DEFB ZX_Q DEFB ZX_W DEFB ZX_E DEFB ZX_R DEFB ZX_T DEFB ZX_1 DEFB ZX_2 DEFB ZX_3 DEFB ZX_4 DEFB ZX_5 DEFB ZX_0 DEFB ZX_9 DEFB ZX_8 DEFB ZX_7 DEFB ZX_6 DEFB ZX_P DEFB ZX_O DEFB ZX_I DEFB ZX_U DEFB ZX_Y DEFB ZX_NEWLINE DEFB ZX_L DEFB ZX_K DEFB ZX_J DEFB ZX_H DEFB ZX_SPACE DEFB ZX_PERIOD DEFB ZX_M DEFB ZX_N DEFB ZX_B
; THE 'SHIFTED' CHARACTER CODES
mark_00A5: K_SHIFT: DEFB ZX_COLON ; : DEFB ZX_SEMICOLON ; ; DEFB ZX_QUERY ; ? DEFB ZX_SLASH ; / DEFB ZX_STOP DEFB ZX_LPRINT DEFB ZX_SLOW DEFB ZX_FAST DEFB ZX_LLIST DEFB $C0 ; "" DEFB ZX_OR DEFB ZX_STEP DEFB $DB ; <= DEFB $DD ; <> DEFB ZX_EDIT DEFB ZX_AND DEFB ZX_THEN DEFB ZX_TO DEFB $72 ; cursor-left DEFB ZX_RUBOUT DEFB ZX_GRAPHICS DEFB $73 ; cursor-right DEFB $70 ; cursor-up DEFB $71 ; cursor-down DEFB ZX_QUOTE ; " DEFB $11 ; ) DEFB $10 ; ( DEFB ZX_DOLLAR ; $ DEFB $DC ; >= DEFB ZX_FUNCTION DEFB ZX_EQUAL DEFB ZX_PLUS DEFB ZX_MINUS DEFB ZX_POWER ; ** DEFB ZX_POUND ; £ DEFB ZX_COMMA ; , DEFB ZX_GREATER_THAN ; > DEFB ZX_LESS_THAN ; < DEFB ZX_STAR ; *
; THE 'FUNCTION' CHARACTER CODES
mark_00CC: K_FUNCT: DEFB ZX_LN DEFB ZX_EXP DEFB ZX_AT DEFB ZX_KL DEFB ZX_ASN DEFB ZX_ACS DEFB ZX_ATN DEFB ZX_SGN DEFB ZX_ABS DEFB ZX_SIN DEFB ZX_COS DEFB ZX_TAN DEFB ZX_INT DEFB ZX_RND DEFB ZX_KL DEFB ZX_KL DEFB ZX_KL DEFB ZX_KL DEFB ZX_KL DEFB ZX_KL DEFB ZX_KL DEFB ZX_KL DEFB ZX_KL DEFB ZX_KL DEFB ZX_TAB DEFB ZX_PEEK DEFB ZX_CODE DEFB ZX_CHR_STR ; CHR$ DEFB ZX_STR_STR ; STR$ DEFB ZX_KL DEFB ZX_USR DEFB ZX_LEN DEFB ZX_VAL DEFB ZX_SQR DEFB ZX_KL DEFB ZX_KL DEFB ZX_PI DEFB ZX_NOT DEFB ZX_INKEY_STR
; THE 'GRAPHIC' CHARACTER CODES
mark_00F3: K_GRAPH: DEFB $08 ; graphic DEFB $0A ; graphic DEFB $09 ; graphic DEFB $8A ; graphic DEFB $89 ; graphic DEFB $81 ; graphic DEFB $82 ; graphic DEFB $07 ; graphic DEFB $84 ; graphic DEFB $06 ; graphic DEFB $01 ; graphic DEFB $02 ; graphic DEFB $87 ; graphic DEFB $04 ; graphic DEFB $05 ; graphic DEFB ZX_RUBOUT DEFB ZX_KL DEFB $85 ; graphic DEFB $03 ; graphic DEFB $83 ; graphic DEFB $8B ; graphic DEFB $91 ; inverse ) DEFB $90 ; inverse ( DEFB $8D ; inverse $ DEFB $86 ; graphic DEFB ZX_KL DEFB $92 ; inverse > DEFB $95 ; inverse + DEFB $96 ; inverse - DEFB $88 ; graphic
; THE 'TOKEN' TABLES
mark_0111: TOKEN_TABLE: DEFB ZX_QUERY +$80; '?' DEFB ZX_QUOTE, ZX_QUOTE +$80; "" DEFB ZX_A, ZX_T +$80; AT DEFB ZX_T, ZX_A, ZX_B +$80; TAB DEFB ZX_QUERY +$80; '?' DEFB ZX_C, ZX_O, ZX_D, ZX_E +$80; CODE DEFB ZX_V, ZX_A, ZX_L +$80; VAL DEFB ZX_L, ZX_E, ZX_N +$80; LEN DEFB ZX_S, ZX_I, ZX_N +$80; SIN DEFB ZX_C, ZX_O, ZX_S +$80; COS DEFB ZX_T, ZX_A, ZX_N +$80; TAN DEFB ZX_A, ZX_S, ZX_N +$80; ASN DEFB ZX_A, ZX_C, ZX_S +$80; ACS DEFB ZX_A, ZX_T, ZX_N +$80; ATN DEFB ZX_L, ZX_N +$80; LN DEFB ZX_E, ZX_X, ZX_P +$80; EXP DEFB ZX_I, ZX_N, ZX_T +$80; INT DEFB ZX_S, ZX_Q, ZX_R +$80; SQR DEFB ZX_S, ZX_G, ZX_N +$80; SGN DEFB ZX_A, ZX_B, ZX_S +$80; ABS DEFB ZX_P, ZX_E, ZX_E, ZX_K +$80; PEEK DEFB ZX_U, ZX_S, ZX_R +$80; USR DEFB ZX_S, ZX_T, ZX_R, ZX_DOLLAR +$80; STR$ DEFB ZX_C, ZX_H, ZX_R, ZX_DOLLAR +$80; CHR$ DEFB ZX_N, ZX_O, ZX_T +$80; NOT DEFB ZX_STAR, ZX_STAR +$80; ** DEFB ZX_O, ZX_R +$80; OR DEFB ZX_A, ZX_N, ZX_D +$80; AND DEFB ZX_LESS_THAN, ZX_EQUAL +$80; >= DEFB ZX_GREATER_THAN, ZX_EQUAL +$80; <= DEFB ZX_LESS_THAN, ZX_GREATER_THAN +$80; >< DEFB ZX_T, ZX_H, ZX_E, ZX_N +$80; THEN DEFB ZX_T, ZX_O +$80; TO DEFB ZX_S, ZX_T, ZX_E, ZX_P +$80; STEP DEFB ZX_L, ZX_P, ZX_R, ZX_I, ZX_N, ZX_T +$80; LPRINT DEFB ZX_L, ZX_L, ZX_I, ZX_S, ZX_T +$80; LLIST DEFB ZX_S, ZX_T, ZX_O, ZX_P +$80; STOP DEFB ZX_S, ZX_L, ZX_O, ZX_W +$80; SLOW DEFB ZX_F, ZX_A, ZX_S, ZX_T +$80; FAST DEFB ZX_N, ZX_E, ZX_W +$80; NEW DEFB ZX_S, ZX_C, ZX_R, ZX_O, ZX_L, ZX_L +$80; SCROLL DEFB ZX_C, ZX_O, ZX_N, ZX_T +$80; CONT DEFB ZX_D, ZX_I, ZX_M +$80; DIM DEFB ZX_R, ZX_E, ZX_M +$80; REM DEFB ZX_F, ZX_O, ZX_R +$80; FOR DEFB ZX_G, ZX_O, ZX_T, ZX_O +$80; GOTO DEFB ZX_G, ZX_O, ZX_S, ZX_U, ZX_B +$80; GOSUB DEFB ZX_I, ZX_N, ZX_P, ZX_U, ZX_T +$80; INPUT DEFB ZX_L, ZX_O, ZX_A, ZX_D +$80; LOAD DEFB ZX_L, ZX_I, ZX_S, ZX_T +$80; LIST DEFB ZX_L, ZX_E, ZX_T +$80; LET DEFB ZX_P, ZX_A, ZX_U, ZX_S, ZX_E +$80; PAUSE DEFB ZX_N, ZX_E, ZX_X, ZX_T +$80; NEXT DEFB ZX_P, ZX_O, ZX_K, ZX_E +$80; POKE DEFB ZX_P, ZX_R, ZX_I, ZX_N, ZX_T +$80; PRINT DEFB ZX_P, ZX_L, ZX_O, ZX_T +$80; PLOT DEFB ZX_R, ZX_U, ZX_N +$80; RUN DEFB ZX_S, ZX_A, ZX_V, ZX_E +$80; SAVE DEFB ZX_R, ZX_A, ZX_N, ZX_D +$80; RAND DEFB ZX_I, ZX_F +$80; IF DEFB ZX_C, ZX_L, ZX_S +$80; CLS DEFB ZX_U, ZX_N, ZX_P, ZX_L, ZX_O, ZX_T +$80; UNPLOT DEFB ZX_C, ZX_L, ZX_E, ZX_A, ZX_R +$80; CLEAR DEFB ZX_R, ZX_E, ZX_T, ZX_U, ZX_R, ZX_N +$80; RETURN DEFB ZX_C, ZX_O, ZX_P, ZX_Y +$80; COPY DEFB ZX_R, ZX_N, ZX_D +$80; RND DEFB ZX_I, ZX_N, ZX_K, ZX_E, ZX_Y, ZX_DOLLAR +$80; INKEY$ DEFB ZX_P, ZX_I +$80; PI
; THE 'LOAD_SAVE UPDATE' ROUTINE
; ; mark_01FC: LOAD_SAVE: INC HL ; EX DE,HL ; LD HL,(E_LINE) ; system variable edit line E_LINE. SCF ; set carry flag SBC HL,DE ; EX DE,HL ; RET NC ; return if more bytes to LOAD_SAVE. POP HL ; else drop return address
; THE 'DISPLAY' ROUTINES
; ; mark_0207: SLOW_FAST: LD HL,CDFLAG ; Address the system variable CDFLAG. LD A,(HL) ; Load value to the accumulator. RLA ; rotate bit 6 to position 7. XOR (HL) ; exclusive or with original bit 7. RLA ; rotate result out to carry. RET NC ; return if both bits were the same. ; Now test if this really is a ZX81 or a ZX80 running the upgraded ROM. ; The standard ZX80 did not have an NMI generator. LD A,$7F ; Load accumulator with %011111111 EX AF,AF' ; save in AF' LD B,17 ; A counter within which an NMI should occur ; if this is a ZX81. OUT (IO_PORT_NMI_GEN_ON),A ; start the NMI generator. ; Note that if this is a ZX81 then the NMI will increment AF'. mark_0216: LOOP_11: DJNZ LOOP_11 ; self loop to give the NMI a chance to kick in. ; = 16*13 clock cycles + 8 = 216 clock cycles. OUT (IO_PORT_NMI_GEN_OFF),A ; Turn off the NMI generator. EX AF,AF' ; bring back the AF' value. RLA ; test bit 7. JR NC,NO_SLOW ; forward, if bit 7 is still reset, to NO_SLOW. ; If the AF' was incremented then the NMI generator works and SLOW mode can ; be set. SET 7,(HL) ; Indicate SLOW mode - Compute and Display. PUSH AF ; * Save Main Registers PUSH BC ; ** PUSH DE ; *** PUSH HL ; **** JR DISPLAY_1 ; skip forward - to DISPLAY_1. ; ___ mark_0226: NO_SLOW: RES 6,(HL) ; reset bit 6 of CDFLAG. RET ; return.
; THE 'MAIN DISPLAY' LOOP
; This routine is executed once for every frame displayed. mark_0229: DISPLAY_1: LD HL,(FRAMES) ; fetch two-byte system variable FRAMES. DEC HL ; decrement frames counter. mark_022D: DISPLAY_P: LD A,$7F ; prepare a mask AND H ; pick up bits 6-0 of H. OR L ; and any bits of L. LD A,H ; reload A with all bits of H for PAUSE test. ; Note both branches must take the same time. JR NZ,ANOTHER ; (12/7) forward if bits 14-0 are not zero ; to ANOTHER RLA ; (4) test bit 15 of FRAMES. JR OVER_NC ; (12) forward with result to OVER_NC ; ___ mark_0237: ANOTHER: LD B,(HL) ; (7) Note. Harmless Nonsensical Timing weight. SCF ; (4) Set Carry Flag. ; Note. the branch to here takes either (12)(7)(4) cyles or (7)(4)(12) cycles. mark_0239: OVER_NC: LD H,A ; (4) set H to zero LD (FRAMES),HL ; (16) update system variable FRAMES RET NC ; (11/5) return if FRAMES is in use by PAUSE ; command. mark_023E: DISPLAY_2: CALL KEYBOARD ; gets the key row in H and the column in L. ; Reading the ports also starts ; the TV frame synchronization pulse. (VSYNC) LD BC,(LAST_K) ; fetch the last key values LD (LAST_K),HL ; update LAST_K with new values. LD A,B ; load A with previous column - will be $FF if ; there was no key. ADD A,2 ; adding two will set carry if no previous key. SBC HL,BC ; subtract with the carry the two key values. ; If the same key value has been returned twice then HL will be zero. LD A,(DEBOUNCE_VAR) OR H ; and OR with both bytes of the difference OR L ; setting the zero flag for the upcoming branch. LD E,B ; transfer the column value to E LD B,11 ; and load B with eleven LD HL,CDFLAG ; address system variable CDFLAG RES 0,(HL) ; reset the rightmost bit of CDFLAG JR NZ,NO_KEY ; skip forward if debounce/diff >0 to NO_KEY BIT 7,(HL) ; test compute and display bit of CDFLAG SET 0,(HL) ; set the rightmost bit of CDFLAG. RET Z ; return if bit 7 indicated fast mode. DEC B ; (4) decrement the counter. NOP ; (4) Timing - 4 clock cycles. ?? SCF ; (4) Set Carry Flag mark_0264: NO_KEY: LD HL,DEBOUNCE_VAR ; CCF ; Complement Carry Flag RL B ; rotate left B picking up carry ; C<-76543210<-C mark_026A: LOOP_B: DJNZ LOOP_B ; self-loop while B>0 to LOOP_B LD B,(HL) ; fetch value of DEBOUNCE_VAR to B LD A,E ; transfer column value CP $FE ; SBC A,A ; A = A-A-C = 0-Carry #if 1 ; I think this truncating DEBOUNCE_VAR ; which would explain why the VSYNC time didn't match ; my calculations that assumed debouncing for 255 loops. ; ; LD B,$1F ; binary 000 11111 OR (HL) ; AND B ; truncate column, 0 to 31 #endif RRA ; LD (HL),A ; OUT (IO_PORT_SCREEN),A ; end the TV frame synchronization pulse. LD HL,(D_FILE) ; (12) set HL to the Display File from D_FILE SET 7,H ; (8) set bit 15 to address the echo display. CALL DISPLAY_3 ; (17) routine DISPLAY_3 displays the top set ; of blank lines.
; THE 'VIDEO_1' ROUTINE
mark_0281: R_IX_1: LD A,R ; (9) Harmless Nonsensical Timing ; or something very clever? LD BC,25*256+1 ; (10) 25 lines, 1 scanline in first. ($1901) ; 32 characters, use $F5 (i.e. minus 11) ; 40 characters, use $ED (i.e. minus 19) ; mark_0286: LD A,277-CHARS_PER_LINE_WINDOW ; $F5 for 6.5MHz clocked machines ; (7) This value will be loaded into R and ; ensures that the cycle starts at the right ; part of the display - after last character ; position. CALL DISPLAY_5 ; (17) routine DISPLAY_5 completes the current ; blank line and then generates the display of ; the live picture using INT interrupts ; The final interrupt returns to the next ; address. R_IX_1_LAST_NEWLINE: DEC HL ; point HL to the last NEWLINE/HALT. CALL DISPLAY_3 ; displays the bottom set of blank lines. ; ___ mark_028F: R_IX_2: JP DISPLAY_1 ; JUMP back to DISPLAY_1
; THE 'DISPLAY BLANK LINES' ROUTINE
; This subroutine is called twice (see above) to generate first the blank ; lines at the top of the television display and then the blank lines at the ; bottom of the display. ; ; It is actually pretty bad. ; PAL or NTSC = 312 or ; 1 to 5 = 5 long and 5 short sync ; 6 to 23 = blank ; 24 to 309 = image ; 310 to 312 = 6 short sync ; ; The ZX80 generates either 62 or 110 blank lines ; ; 262 - 31 - 31 = 200 ; 312 - 55 - 55 = 202 ; ; This does not include 'VSYNC' line periods. ; mark_0292: DISPLAY_3: POP IX ; pop the return address to IX register. ; will be either R_IX_1 or R_IX_2 - see above. LD C,(IY+MARGIN-RAMBASE) ; load C with value of system constant MARGIN. BIT 7,(IY+CDFLAG-RAMBASE) ; test CDFLAG for compute and display. JR Z,DISPLAY_4 ; forward, with FAST mode, to DISPLAY_4 LD A,C ; move MARGIN to A - 31d or 55d. NEG ; Negate INC A ; EX AF,AF' ; place negative count of blank lines in A' OUT (IO_PORT_NMI_GEN_ON),A ; enable the NMI generator. POP HL ; **** POP DE ; *** POP BC ; ** POP AF ; * Restore Main Registers RET ; return - end of interrupt. Return is to ; user's program - BASIC or machine code. ; which will be interrupted by every NMI.
; THE 'FAST MODE' ROUTINES
mark_02A9: DISPLAY_4: LD A,284-CHARS_PER_LINE_WINDOW ; $FC for 6.5MHz clocked machines ; (7) load A with first R delay value LD B,1 ; (7) one row only. CALL DISPLAY_5 ; (17) routine DISPLAY_5 DEC HL ; (6) point back to the HALT. EX (SP),HL ; (19) Harmless Nonsensical Timing if paired. EX (SP),HL ; (19) Harmless Nonsensical Timing. JP (IX) ; (8) to R_IX_1 or R_IX_2
; THE 'DISPLAY_5' SUBROUTINE
; This subroutine is called from SLOW mode and FAST mode to generate the ; central TV picture. With SLOW mode the R register is incremented, with ; each instruction, to $F7 by the time it completes. With fast mode, the ; final R value will be $FF and an interrupt will occur as soon as the ; Program Counter reaches the HALT. (24 clock cycles) mark_02B5: DISPLAY_5: LD R,A ; (9) Load R from A. R = slow: $F5 fast: $FC ;; Original, for 32 column display: ;; ;; LD A,$DD ; (7) load future R value. $F6 $FD ;; ;; For other display widths, ;; need to count down three instructions then the number of characters ;; LD A,256-3-CHARS_PER_LINE_WINDOW ; (7) load future R value. $F6 $FD EI ; (4) Enable Interrupts $F7 $FE JP (HL) ; (4) jump to the echo display. $F8 $FF
; THE 'KEYBOARD SCANNING' SUBROUTINE
; The keyboard is read during the vertical sync interval while no video is ; being displayed. Reading a port with address bit 0 low i.e. $FE starts the ; vertical sync pulse. mark_02BB: KEYBOARD: LD HL,$FFFF ; (16) prepare a buffer to take key. LD BC,$FEFE ; (20) set BC to port $FEFE. The B register, ; with its single reset bit also acts as ; an 8-counter. IN A,(C) ; (11) read the port - all 16 bits are put on ; the address bus. Start VSYNC pulse. OR $01 ; (7) set the rightmost bit so as to ignore ; the SHIFT key. mark_02C5: EACH_LINE: OR $E0 ; [7] OR %11100000 LD D,A ; [4] transfer to D. CPL ; [4] complement - only bits 4-0 meaningful now. CP 1 ; [7] sets carry if A is zero. SBC A,A ; [4] $FF if $00 else zero. OR B ; [7] $FF or port FE,FD,FB.... AND L ; [4] unless more than one key, L will still be ; $FF. if more than one key is pressed then A is ; now invalid. LD L,A ; [4] transfer to L. ; now consider the column identifier. LD A,H ; [4] will be $FF if no previous keys. AND D ; [4] 111xxxxx LD H,A ; [4] transfer A to H ; since only one key may be pressed, H will, if valid, be one of ; 11111110, 11111101, 11111011, 11110111, 11101111 ; reading from the outer column, say Q, to the inner column, say T. RLC B ; [8] rotate the 8-counter/port address. ; sets carry if more to do. IN A,(C) ; [10] read another half-row. ; all five bits this time. JR C,EACH_LINE ; [12](7) loop back, until done, to EACH_LINE ; The last row read is SHIFT,Z,X,C,V for the second time. RRA ; (4) test the shift key - carry will be reset ; if the key is pressed. RL H ; (8) rotate left H picking up the carry giving ; column values - ; $FD, $FB, $F7, $EF, $DF. ; or $FC, $FA, $F6, $EE, $DE if shifted. ; We now have H identifying the column and L identifying the row in the ; keyboard matrix. ; This is a good time to test if this is an American or British machine. ; The US machine has an extra diode that causes bit 6 of a byte read from ; a port to be reset. RLA ; (4) compensate for the shift test. RLA ; (4) rotate bit 7 out. RLA ; (4) test bit 6. SBC A,A ; (4) $FF or 0 {USA} AND $18 ; (7) 24 or 0 ADD A,31 ; (7) 55 or 31 ; result is either 31 (USA) or 55 (UK) blank lines above and below the TV ; picture. LD (MARGIN),A ; (13) update system variable MARGIN RET ; (10) return
; THE 'SET FAST MODE' SUBROUTINE
; ; mark_02E7: SET_FAST: BIT 7,(IY+CDFLAG-RAMBASE) RET Z ; HALT ; Wait for Interrupt OUT (IO_PORT_NMI_GEN_OFF),A ; RES 7,(IY+CDFLAG-RAMBASE) RET ; return.
; THE 'REPORT_F'
mark_02F4: REPORT_F: RST _ERROR_1 DEFB $0E ; Error Report: No Program Name supplied.
; THE 'SAVE COMMAND' ROUTINE
; ; mark_02F6: SAVE: CALL NAME JR C,REPORT_F ; back with null name EX DE,HL ; ; ; The next 6 bytes differ ; #if NOT_BODGED ; what ZASM assembled: ; 02FC: 11CB12 LD DE,$12CB ; five seconds timing value (4811 decimal) ; 02FF: CD460F mark_02FF: HEADER: CALL BREAK_1 #else ; what the SG ROM disassembled to: ; 02FC ED;FD LDIR ; Patch tape SAVE ; 02FE C3;07;02 JP SLOW_FAST ; to $0207 ; 0301 0F RRCA #endif mark_0302: JR NC,BREAK_2 mark_0304: DELAY_1: DJNZ DELAY_1 DEC DE ; LD A,D ; OR E ; JR NZ,HEADER ; back for delay to HEADER mark_030B: OUT_NAME: CALL OUT_BYTE BIT 7,(HL) ; test for inverted bit. INC HL ; address next character of name. JR Z,OUT_NAME ; back if not inverted to OUT_NAME ; now start saving the system variables onwards. LD HL,VERSN ; set start of area to VERSN thereby ; preserving RAMTOP etc. mark_0316: OUT_PROG: CALL OUT_BYTE CALL LOAD_SAVE ; >> JR OUT_PROG ; loop back
; THE 'OUT_BYTE' SUBROUTINE
; This subroutine outputs a byte a bit at a time to a domestic tape recorder. mark_031E: OUT_BYTE: LD E,(HL) ; fetch byte to be saved. SCF ; set carry flag - as a marker. mark_0320: EACH_BIT: RL E ; C < 76543210 < C RET Z ; return when the marker bit has passed ; right through. >> SBC A,A ; $FF if set bit or $00 with no carry. AND $05 ; $05 " " " " $00 ADD A,$04 ; $09 " " " " $04 LD C,A ; transfer timer to C. a set bit has a longer ; pulse than a reset bit. mark_0329: PULSES: OUT (IO_PORT_TAPE),A ; pulse to cassette. LD B,$23 ; set timing constant mark_032D: DELAY_2: DJNZ DELAY_2 ; self-loop CALL BREAK_1 ; test for BREAK key. mark_0332: BREAK_2: JR NC,REPORT_D ; forward with break to REPORT_D LD B,$1E ; set timing value. mark_0336: DELAY_3: DJNZ DELAY_3 ; self-loop DEC C ; decrement counter JR NZ,PULSES ; loop back mark_033B: DELAY_4: AND A ; clear carry for next bit test. DJNZ DELAY_4 ; self loop (B is zero - 256) JR EACH_BIT ; loop back
; THE 'LOAD COMMAND' ROUTINE
mark_0340: LOAD: CALL NAME ; DE points to start of name in RAM. RL D ; pick up carry RRC D ; carry now in bit 7. mark_0347: #if NOT_BODGED LNEXT_PROG: CALL IN_BYTE JR LNEXT_PROG ; loop
; THE 'IN_BYTE' SUBROUTINE
mark_034C: IN_BYTE: LD C,$01 ; prepare an eight counter 00000001. mark_034E: NEXT_BIT: LD B,$00 ; set counter to 256 #else ; what the SG ROM has: ;0347 EB EX DE,HL ; NEXT-PROG ;0348 ED;FC LDIR ; Patch tape LOAD ;034A C3;07;02 JP SLOW_FAST ;034D 01;06;00 LD BC,6 #endif mark_0350: BREAK_3: LD A,$7F ; read the keyboard row IN A,(IO_PORT_KEYBOARD_RD) ; with the SPACE key. OUT (IO_PORT_SCREEN),A ; output signal to screen. RRA ; test for SPACE pressed. JR NC,BREAK_4 ; forward if so to BREAK_4 RLA ; reverse above rotation RLA ; test tape bit. JR C,GET_BIT ; forward if set to GET_BIT DJNZ BREAK_3 ; loop back POP AF ; drop the return address. CP D ; ugh. mark_0361: RESTART: JP NC,INITIAL ; jump forward to INITIAL if D is zero ; to reset the system ; if the tape signal has timed out for example ; if the tape is stopped. Not just a simple ; report as some system variables will have ; been overwritten. LD H,D ; else transfer the start of name LD L,E ; to the HL register mark_0366: IN_NAME: CALL IN_BYTE ; is sort of recursion for name ; part. received byte in C. BIT 7,D ; is name the null string ? LD A,C ; transfer byte to A. JR NZ,MATCHING ; forward with null string CP (HL) ; else compare with string in memory. JR NZ,LNEXT_PROG ; back with mis-match ; (seemingly out of subroutine but return ; address has been dropped). mark_0371: MATCHING: INC HL ; address next character of name RLA ; test for inverted bit. JR NC,IN_NAME ; back if not ; the name has been matched in full. ; proceed to load the data but first increment the high byte of E_LINE, which ; is one of the system variables to be loaded in. Since the low byte is loaded ; before the high byte, it is possible that, at the in-between stage, a false ; value could cause the load to end prematurely - see LOAD_SAVE check. INC (IY+E_LINE_hi-RAMBASE) ; increment E_LINE_hi. LD HL,VERSN ; start loading at VERSN. mark_037B: IN_PROG: LD D,B ; set D to zero as indicator. CALL IN_BYTE ; loads a byte LD (HL),C ; insert assembled byte in memory. CALL LOAD_SAVE ; >> JR IN_PROG ; loop back ; ___ ; this branch assembles a full byte before exiting normally ; from the IN_BYTE subroutine. mark_0385: GET_BIT: PUSH DE ; save the LD E,$94 ; timing value. mark_0388: TRAILER: LD B,26 ; counter to twenty six. mark_038A: COUNTER: DEC E ; decrement the measuring timer. IN A,(IO_PORT_KEYBOARD_RD) ; read the tape input RLA ; BIT 7,E ; LD A,E ; JR C,TRAILER ; loop back with carry to TRAILER DJNZ COUNTER POP DE ; JR NZ,BIT_DONE CP $56 ; JR NC,NEXT_BIT mark_039C: BIT_DONE: CCF ; complement carry flag RL C ; JR NC,NEXT_BIT RET ; return with full byte. ; ___ ; if break is pressed while loading data then perform a reset. ; if break pressed while waiting for program on tape then OK to break. mark_03A2: BREAK_4: LD A,D ; transfer indicator to A. AND A ; test for zero. JR Z,RESTART ; back if so mark_03A6: REPORT_D: RST _ERROR_1 DEFB $0C ; Error Report: BREAK - CONT repeats
; THE 'PROGRAM NAME' SUBROUTINE
mark_03A8: NAME: CALL SCANNING LD A,(FLAGS) ; sv ADD A,A ; JP M,REPORT_C POP HL ; RET NC ; PUSH HL ; CALL SET_FAST CALL STK_FETCH LD H,D ; LD L,E ; DEC C ; RET M ; ADD HL,BC ; SET 7,(HL) ; RET ;
; THE 'NEW' COMMAND ROUTINE
mark_03C3: NEW: CALL SET_FAST LD BC,(RAMTOP) ; fetch value of system variable RAMTOP DEC BC ; point to last system byte.
; THE 'RAM CHECK' ROUTINE
mark_03CB: RAM_CHECK: LD H,B ; LD L,C ; LD A,$3F ; mark_03CF: RAM_FILL: LD (HL),$02 ; DEC HL ; CP H ; JR NZ,RAM_FILL mark_03D5: RAM_READ: AND A ; SBC HL,BC ; ADD HL,BC ; INC HL ; JR NC,SET_TOP DEC (HL) ; JR Z,SET_TOP DEC (HL) ; JR Z,RAM_READ mark_03E2: SET_TOP: LD (RAMTOP),HL ; set system variable RAMTOP to first byte ; above the BASIC system area.
; THE 'INITIALIZATION' ROUTINE
mark_03E5: INITIAL: LD HL,(RAMTOP) ; fetch system variable RAMTOP. DEC HL ; point to last system byte. LD (HL),$3E ; make GO SUB end-marker $3E - too high for ; high order byte of line number. ; (was $3F on ZX80) DEC HL ; point to unimportant low-order byte. LD SP,HL ; and initialize the stack-pointer to this ; location. DEC HL ; point to first location on the machine stack DEC HL ; which will be filled by next CALL/PUSH. LD (ERR_SP),HL ; set the error stack pointer ERR_SP to ; the base of the now empty machine stack. ; Now set the I register so that the video hardware knows where to find the ; character set. This ROM only uses the character set when printing to ; the ZX Printer. The TV picture is formed by the external video hardware. ; Consider also, that this 8K ROM can be retro-fitted to the ZX80 instead of ; its original 4K ROM so the video hardware could be on the ZX80. LD A,$1E ; address for this ROM is $1E00. LD I,A ; set I register from A. IM 1 ; select Z80 Interrupt Mode 1. LD IY,ERR_NR ; set IY to the start of RAM so that the ; system variables can be indexed. LD (IY+CDFLAG-RAMBASE),%01000000 ; Bit 6 indicates Compute and Display required. LD HL,USER_RAM ; The first location after System Variables - ; 16509 decimal. LD (D_FILE),HL ; set system variable D_FILE to this value. LD B,$19 ; prepare minimal screen of 24 NEWLINEs ; following an initial NEWLINE. mark_0408: LINE: LD (HL),ZX_NEWLINE ; insert NEWLINE (HALT instruction) INC HL ; point to next location. DJNZ LINE ; loop back for all twenty five to LINE LD (VARS),HL ; set system variable VARS to next location CALL CLEAR ; sets $80 end-marker and the ; dynamic memory pointers E_LINE, STKBOT and ; STKEND. mark_0413: N_L_ONLY: CALL CURSOR_IN ; inserts the cursor and ; end-marker in the Edit Line also setting ; size of lower display to two lines. CALL SLOW_FAST ; selects COMPUTE and DISPLAY
; THE 'BASIC LISTING' SECTION
mark_0419: UPPER: CALL CLS LD HL,(E_PPC) ; sv LD DE,(S_TOP) ; sv AND A ; SBC HL,DE ; EX DE,HL ; JR NC,ADDR_TOP ADD HL,DE ; LD (S_TOP),HL ; sv mark_042D: ADDR_TOP: CALL LINE_ADDR JR Z,LIST_TOP EX DE,HL ; mark_0433: LIST_TOP: CALL LIST_PROG DEC (IY+BERG-RAMBASE) JR NZ,LOWER LD HL,(E_PPC) ; sv CALL LINE_ADDR LD HL,(CH_ADD) ; sv SCF ; Set Carry Flag SBC HL,DE ; LD HL,S_TOP ; sv JR NC,INC_LINE EX DE,HL ; LD A,(HL) ; INC HL ; LDI ; LD (DE),A ; JR UPPER ; ___ mark_0454: DOWN_KEY: LD HL,E_PPC ; sv mark_0457: INC_LINE: LD E,(HL) ; INC HL ; LD D,(HL) ; PUSH HL ; EX DE,HL ; INC HL ; CALL LINE_ADDR CALL LINE_NUM POP HL ; mark_0464: KEY_INPUT: BIT 5,(IY+FLAGX-RAMBASE) JR NZ,LOWER ; forward LD (HL),D ; DEC HL ; LD (HL),E ; JR UPPER
; THE 'EDIT LINE COPY' SECTION
; This routine sets the edit line to just the cursor when ; 1) There is not enough memory to edit a BASIC line. ; 2) The edit key is used during input. ; The entry point LOWER mark_046F: EDIT_INP: CALL CURSOR_IN ; sets cursor only edit line. ; -> mark_0472: LOWER: LD HL,(E_LINE) ; fetch edit line start from E_LINE. mark_0475: EACH_CHAR: LD A,(HL) ; fetch a character from edit line. CP $7E ; compare to the number marker. JR NZ,END_LINE ; forward if not LD BC,6 ; else six invisible bytes to be removed. CALL RECLAIM_2 JR EACH_CHAR ; back ; ___ mark_0482: END_LINE: CP ZX_NEWLINE ; INC HL ; JR NZ,EACH_CHAR mark_0487: EDIT_LINE: CALL CURSOR ; sets cursor K or L. mark_048A: EDIT_ROOM: CALL LINE_ENDS LD HL,(E_LINE) ; sv LD (IY+ERR_NR-RAMBASE),$FF CALL COPY_LINE BIT 7,(IY+ERR_NR-RAMBASE) JR NZ,DISPLAY_6 LD A,(DF_SZ) ; CP CHARS_VERTICAL ; $18 = 24 JR NC,DISPLAY_6 INC A ; LD (DF_SZ),A ; LD B,A ; LD C,1 ; CALL LOC_ADDR LD D,H ; LD E,L ; LD A,(HL) ; mark_04B1: FREE_LINE: DEC HL ; CP (HL) ; JR NZ,FREE_LINE INC HL ; EX DE,HL ; LD A,(RAMTOP+1) ; sv RAMTOP_hi CP $4D ; CALL C,RECLAIM_1 JR EDIT_ROOM
; THE 'WAIT FOR KEY' SECTION
mark_04C1: DISPLAY_6: LD HL,$0000 ; LD (X_PTR),HL ; sv LD HL,CDFLAG ; system variable CDFLAG #if NOT_BODGED BIT 7,(HL) ; CALL Z,DISPLAY_1 mark_04CF: SLOW_DISP: BIT 0,(HL) ; JR Z,SLOW_DISP #else ; 04CA D3;00 OUT ($00),A ; PORT 0 ; 04CC CB;46 L04CC: BIT 0,(HL) ; 04CE 28;FC JR Z,L04CC ; 04D0 D3;01 OUT ($01),A ; PORT 1 ; 04D2 00 NOP #endif LD BC,(LAST_K) ; sv CALL DEBOUNCE CALL DECODE JR NC,LOWER ; back
; THE 'KEYBOARD DECODING' SECTION
; The decoded key value is in E and HL points to the position in the ; key table. D contains zero. mark_04DF: K_DECODE: LD A,(MODE) ; Fetch value of system variable MODE DEC A ; test the three values together JP M,FETCH_2 ; forward, if was zero JR NZ,FETCH_1 ; forward, if was 2 ; The original value was one and is now zero. LD (MODE),A ; update the system variable MODE DEC E ; reduce E to range $00 - $7F LD A,E ; place in A SUB 39 ; subtract 39 setting carry if range 00 - 38 JR C,FUNC_BASE ; forward, if so LD E,A ; else set E to reduced value mark_04F2: FUNC_BASE: LD HL,K_FUNCT ; address of K_FUNCT table for function keys. JR TABLE_ADD ; forward ; ___ mark_04F7: FETCH_1: LD A,(HL) ; CP ZX_NEWLINE ; JR Z,K_L_KEY CP ZX_RND ; $40 SET 7,A ; JR C,ENTER LD HL,$00C7 ; (expr reqd) mark_0505: TABLE_ADD: ADD HL,DE ; JR FETCH_3 ; ___ mark_0508: FETCH_2: LD A,(HL) ; BIT 2,(IY+FLAGS-RAMBASE) ; K or L mode ? JR NZ,TEST_CURS ADD A,$C0 ; CP $E6 ; JR NC,TEST_CURS mark_0515: FETCH_3: LD A,(HL) ; mark_0516: TEST_CURS: CP $F0 ; JP PE,KEY_SORT mark_051B: ENTER: LD E,A ; CALL CURSOR LD A,E ; CALL ADD_CHAR mark_0523: BACK_NEXT: JP LOWER ; back
; THE 'ADD CHARACTER' SUBROUTINE
mark_0526: ADD_CHAR: CALL ONE_SPACE LD (DE),A ; RET ;
; THE 'CURSOR KEYS' ROUTINE
mark_052B: K_L_KEY: LD A,ZX_KL ; mark_052D: KEY_SORT: LD E,A ; LD HL,$0482 ; base address of ED_KEYS (exp reqd) ADD HL,DE ; ADD HL,DE ; LD C,(HL) ; INC HL ; LD B,(HL) ; PUSH BC ; mark_0537: CURSOR: LD HL,(E_LINE) ; sv BIT 5,(IY+FLAGX-RAMBASE) JR NZ,L_MODE mark_0540: K_MODE: RES 2,(IY+FLAGS-RAMBASE) ; Signal use K mode mark_0544: TEST_CHAR: LD A,(HL) ; CP ZX_CURSOR ; RET Z ; return INC HL ; CALL NUMBER JR Z,TEST_CHAR CP ZX_A ; $26 JR C,TEST_CHAR CP $DE ; ZX_THEN ?? JR Z,K_MODE mark_0556: L_MODE: SET 2,(IY+FLAGS-RAMBASE) ; Signal use L mode JR TEST_CHAR
; THE 'CLEAR_ONE' SUBROUTINE
mark_055C: CLEAR_ONE: LD BC,$0001 ; JP RECLAIM_2
; THE 'EDITING KEYS' TABLE
mark_0562: ED_KEYS: DEFW UP_KEY DEFW DOWN_KEY DEFW LEFT_KEY DEFW RIGHT_KEY DEFW FUNCTION DEFW EDIT_KEY DEFW N_L_KEY DEFW RUBOUT DEFW FUNCTION DEFW FUNCTION
; THE 'CURSOR LEFT' ROUTINE
; ; mark_LEFT_KEY: LEFT_KEY: CALL LEFT_EDGE LD A,(HL) ; LD (HL),ZX_CURSOR ; INC HL ; JR GET_CODE
; THE 'CURSOR RIGHT' ROUTINE
mark_RIGHT_KEY: RIGHT_KEY: INC HL ; LD A,(HL) ; CP ZX_NEWLINE ; JR Z,ENDED_2 LD (HL),ZX_CURSOR ; DEC HL ; mark_0588: GET_CODE: LD (HL),A ; mark_0589: ENDED_1: JR BACK_NEXT
; THE 'RUBOUT' ROUTINE
mark_058B: RUBOUT: CALL LEFT_EDGE CALL CLEAR_ONE JR ENDED_1
; THE 'ED_EDGE' SUBROUTINE
; ; mark_0593: LEFT_EDGE: DEC HL ; LD DE,(E_LINE) ; sv LD A,(DE) ; CP ZX_CURSOR ; RET NZ ; POP DE ; mark_059D: ENDED_2: JR ENDED_1
; THE 'CURSOR UP' ROUTINE
; ; mark_059F: UP_KEY: LD HL,(E_PPC) ; sv CALL LINE_ADDR EX DE,HL ; CALL LINE_NUM LD HL,E_PPC+1 ; point to system variable E_PPC_hi JP KEY_INPUT ; jump back
; THE 'FUNCTION KEY' ROUTINE
; ; mark_FUNCTION: FUNCTION: LD A,E ; AND $07 ; LD (MODE),A ; sv JR ENDED_2 ; back
; THE 'COLLECT LINE NUMBER' SUBROUTINE
mark_05B7: ZERO_DE: EX DE,HL ; LD DE,DISPLAY_6 + 1 ; $04C2 - a location addressing two zeros. ; -> mark_05BB: LINE_NUM: LD A,(HL) ; AND $C0 ; JR NZ,ZERO_DE LD D,(HL) ; INC HL ; LD E,(HL) ; RET ;
; THE 'EDIT KEY' ROUTINE
mark_EDIT_KEY: EDIT_KEY: CALL LINE_ENDS ; clears lower display. LD HL,EDIT_INP ; Address: EDIT_INP PUSH HL ; ** is pushed as an error looping address. BIT 5,(IY+FLAGX-RAMBASE) ; test FLAGX RET NZ ; indirect jump if in input mode ; to EDIT_INP (begin again). ; LD HL,(E_LINE) ; fetch E_LINE LD (DF_CC),HL ; and use to update the screen cursor DF_CC ; so now RST $10 will print the line numbers to the edit line instead of screen. ; first make sure that no newline/out of screen can occur while sprinting the ; line numbers to the edit line. ; prepare line 0, column 0. LD HL,256*CHARS_VERTICAL + CHARS_HORIZONTAL + 1 ; LD (S_POSN),HL ; update S_POSN with these dummy values. LD HL,(E_PPC) ; fetch current line from E_PPC may be a ; non-existent line e.g. last line deleted. CALL LINE_ADDR ; gets address or that of ; the following line. CALL LINE_NUM ; gets line number if any in DE ; leaving HL pointing at second low byte. LD A,D ; test the line number for zero. OR E ; RET Z ; return if no line number - no program to edit. DEC HL ; point to high byte. CALL OUT_NO ; writes number to edit line. INC HL ; point to length bytes. LD C,(HL) ; low byte to C. INC HL ; LD B,(HL) ; high byte to B. INC HL ; point to first character in line. LD DE,(DF_CC) ; fetch display file cursor DF_CC LD A,ZX_CURSOR ; prepare the cursor character. LD (DE),A ; and insert in edit line. INC DE ; increment intended destination. PUSH HL ; * save start of BASIC. LD HL,29 ; set an overhead of 29 bytes. ADD HL,DE ; add in the address of cursor. ADD HL,BC ; add the length of the line. SBC HL,SP ; subtract the stack pointer. POP HL ; * restore pointer to start of BASIC. RET NC ; return if not enough room to EDIT_INP EDIT_INP. ; the edit key appears not to work. LDIR ; else copy bytes from program to edit line. ; Note. hidden floating point forms are also ; copied to edit line. EX DE,HL ; transfer free location pointer to HL POP DE ; ** remove address EDIT_INP from stack. CALL SET_STK_B ; sets STKEND from HL. JR ENDED_2 ; back to ENDED_2 and after 3 more jumps ; to LOWER, LOWER. ; Note. The LOWER routine removes the hidden ; floating-point numbers from the edit line.
; THE 'NEWLINE KEY' ROUTINE
mark_060C: N_L_KEY: CALL LINE_ENDS LD HL,LOWER ; prepare address: LOWER BIT 5,(IY+FLAGX-RAMBASE) JR NZ,NOW_SCAN LD HL,(E_LINE) ; sv LD A,(HL) ; CP $FF ; JR Z,STK_UPPER CALL CLEAR_PRB CALL CLS mark_0626: STK_UPPER: LD HL,UPPER ; Address: UPPER mark_0629: NOW_SCAN: PUSH HL ; push routine address (LOWER or UPPER). CALL LINE_SCAN POP HL ; CALL CURSOR CALL CLEAR_ONE CALL E_LINE_NUM JR NZ,N_L_INP LD A,B ; OR C ; JP NZ,N_L_LINE DEC BC ; DEC BC ; LD (PPC),BC ; sv LD (IY+DF_SZ-RAMBASE),2 LD DE,(D_FILE) ; sv JR TEST_NULL ; forward ; ___ mark_064E: N_L_INP: CP ZX_NEWLINE ; JR Z,N_L_NULL LD BC,(T_ADDR) ; CALL LOC_ADDR LD DE,(NXTLIN) ; LD (IY+DF_SZ-RAMBASE),2 mark_0661: TEST_NULL: RST _GET_CHAR CP ZX_NEWLINE ; mark_0664: N_L_NULL: JP Z,N_L_ONLY LD (IY+FLAGS-RAMBASE),$80 EX DE,HL ; mark_066C: NEXT_LINE: LD (NXTLIN),HL ; EX DE,HL ; CALL TEMP_PTR2 CALL LINE_RUN RES 1,(IY+FLAGS-RAMBASE) ; Signal printer not in use LD A,$C0 ; ;; LD (IY+X_PTR_lo-RAMBASE),A ;; ERROR IN htm SOURCE! IY+$19 is X_PTR_hi LD (IY+X_PTR_hi-RAMBASE),A CALL X_TEMP RES 5,(IY+FLAGX-RAMBASE) BIT 7,(IY+ERR_NR-RAMBASE) JR Z,STOP_LINE LD HL,(NXTLIN) ; AND (HL) ; JR NZ,STOP_LINE LD D,(HL) ; INC HL ; LD E,(HL) ; LD (PPC),DE ; INC HL ; LD E,(HL) ; INC HL ; LD D,(HL) ; INC HL ; EX DE,HL ; ADD HL,DE ; CALL BREAK_1 JR C,NEXT_LINE LD HL,ERR_NR BIT 7,(HL) JR Z,STOP_LINE LD (HL),$0C mark_06AE: STOP_LINE: BIT 7,(IY+PR_CC-RAMBASE) CALL Z,COPY_BUFF ; #if 0 LD BC,$0121 ; #else LD BC,256*1 + CHARS_HORIZONTAL + 1 #endif ; ; CALL LOC_ADDR LD A,(ERR_NR) LD BC,(PPC) INC A JR Z,REPORT CP $09 JR NZ,CONTINUE INC BC mark_06CA: CONTINUE: LD (OLDPPC),BC ; JR NZ,REPORT DEC BC ; mark_06D1: REPORT: CALL OUT_CODE LD A,ZX_SLASH RST _PRINT_A CALL OUT_NUM CALL CURSOR_IN JP DISPLAY_6 ; ___ mark_06E0: N_L_LINE: LD (E_PPC),BC ; LD HL,(CH_ADD) ; EX DE,HL ; LD HL,N_L_ONLY PUSH HL ; LD HL,(STKBOT) ; SBC HL,DE ; PUSH HL ; PUSH BC ; CALL SET_FAST CALL CLS POP HL ; CALL LINE_ADDR JR NZ,COPY_OVER CALL NEXT_ONE CALL RECLAIM_2 mark_0705: COPY_OVER: POP BC ; LD A,C ; DEC A ; OR B ; RET Z ; PUSH BC ; INC BC ; INC BC ; INC BC ; INC BC ; DEC HL ; CALL MAKE_ROOM CALL SLOW_FAST POP BC ; PUSH BC ; INC DE ; LD HL,(STKBOT) ; DEC HL ; LDDR ; copy bytes LD HL,(E_PPC) ; EX DE,HL ; POP BC ; LD (HL),B ; DEC HL ; LD (HL),C ; DEC HL ; LD (HL),E ; DEC HL ; LD (HL),D ; RET ; return.
; THE 'LIST' AND 'LLIST' COMMAND ROUTINES
mark_072C: LLIST: SET 1,(IY+FLAGS-RAMBASE) ; signal printer in use mark_0730: LIST: CALL FIND_INT LD A,B ; fetch high byte of user-supplied line number. AND $3F ; and crudely limit to range 1-16383. LD H,A ; LD L,C ; LD (E_PPC),HL ; CALL LINE_ADDR mark_073E: LIST_PROG: LD E,$00 ; mark_0740: UNTIL_END: CALL OUT_LINE ; lists one line of BASIC ; making an early return when the screen is ; full or the end of program is reached. JR UNTIL_END ; loop back to UNTIL_END
; THE 'PRINT A BASIC LINE' SUBROUTINE
mark_0745: OUT_LINE: LD BC,(E_PPC) ; sv CALL CP_LINES LD D,$92 ; JR Z,TEST_END LD DE,$0000 ; RL E ; mark_0755: TEST_END: LD (IY+BERG-RAMBASE),E LD A,(HL) ; CP $40 ; POP BC ; RET NC ; PUSH BC ; CALL OUT_NO INC HL ; LD A,D ; RST _PRINT_A INC HL ; INC HL ; mark_0766: COPY_LINE: LD (CH_ADD),HL ; SET 0,(IY+FLAGS-RAMBASE) ; Suppress leading space mark_076D: MORE_LINE: LD BC,(X_PTR) ; LD HL,(CH_ADD) ; AND A ; SBC HL,BC ; JR NZ,TEST_NUM LD A,ZX_INV_S ; $B8 ; RST _PRINT_A mark_077C: TEST_NUM: LD HL,(CH_ADD) ; LD A,(HL) ; INC HL ; CALL NUMBER LD (CH_ADD),HL ; JR Z,MORE_LINE CP ZX_CURSOR ; JR Z,OUT_CURS CP ZX_NEWLINE ; JR Z,OUT_CH BIT 6,A ; JR Z,NOT_TOKEN CALL TOKENS JR MORE_LINE ; ___ mark_079A: NOT_TOKEN: RST _PRINT_A JR MORE_LINE ; ___ mark_079D: OUT_CURS: LD A,(MODE) ; Fetch value of system variable MODE LD B,$AB ; Prepare an inverse [F] for function cursor. AND A ; Test for zero - JR NZ,FLAGS_2 ; forward if not to FLAGS_2 LD A,(FLAGS) ; Fetch system variable FLAGS. LD B,ZX_INV_K ; Prepare an inverse [K] for keyword cursor. mark_07AA: FLAGS_2: RRA ; 00000?00 -> 000000?0 RRA ; 000000?0 -> 0000000? AND $01 ; 0000000? 0000000x ADD A,B ; Possibly [F] -> [G] or [K] -> [L] CALL PRINT_SP JR MORE_LINE
; THE 'NUMBER' SUBROUTINE
mark_07B4: NUMBER: CP $7E ; RET NZ ; INC HL ; INC HL ; INC HL ; INC HL ; INC HL ; RET ;
; THE 'KEYBOARD DECODE' SUBROUTINE
mark_07BD: DECODE: LD D,0 ; SRA B ; shift bit from B to Carry SBC A,A ; A = 0 - Carry OR $26 ; %00100110 LD L,5 ; SUB L ; mark_07C7: KEY_LINE: ADD A,L ; SCF ; Set Carry Flag RR C ; JR C,KEY_LINE INC C ; RET NZ ; LD C,B ; DEC L ; LD L,1 ; JR NZ,KEY_LINE LD HL,$007D ; (expr reqd) LD E,A ; ADD HL,DE ; SCF ; Set Carry Flag RET ;
; THE 'PRINTING' SUBROUTINE
mark_07DC: LEAD_SP: LD A,E ; AND A ; RET M ; JR PRINT_CH ; ___ ; HL is typically -10000, -1000, -100, -10 ; and repeatedly subtracted from BC ; i.e. it print ; ; mark_07E1: OUT_DIGIT: XOR A ; assume the digit is zero to begin with mark_07E2: DIGIT_INC: ADD HL,BC ; HL += -ve number INC A ; JR C,DIGIT_INC ; loop SBC HL,BC ; undo last iteration DEC A ; undo last iteration JR Z,LEAD_SP ; leading zeros shown as spaces mark_07EB: OUT_CODE: LD E,ZX_0 ; $1C ADD A,E ; mark_07EE: OUT_CH: AND A ; JR Z,PRINT_SP mark_07F1: PRINT_CH: RES 0,(IY+FLAGS-RAMBASE) ; signal leading space permitted mark_07F5: PRINT_SP: EXX ; PUSH HL ; BIT 1,(IY+FLAGS-RAMBASE) ; is printer in use ? JR NZ,LPRINT_A CALL ENTER_CH JR PRINT_EXX ; ___ mark_0802: LPRINT_A: CALL LPRINT_CH mark_0805: PRINT_EXX: POP HL ; EXX ; RET ; ; ___ mark_0808: ENTER_CH: LD D,A ; LD BC,(S_POSN) ; LD A,C ; CP CHARS_HORIZONTAL+1 ; JR Z,TEST_LOW mark_0812: TEST_N_L: LD A,ZX_NEWLINE ; CP D ; JR Z,WRITE_N_L LD HL,(DF_CC) ; CP (HL) ; LD A,D ; JR NZ,WRITE_CH DEC C ; JR NZ,EXPAND_1 INC HL ; LD (DF_CC),HL ; LD C,CHARS_HORIZONTAL+1 ; $21 = 33 normally DEC B ; LD (S_POSN),BC ; mark_082C: TEST_LOW: LD A,B ; CP (IY+DF_SZ-RAMBASE) JR Z,REPORT_5 AND A ; JR NZ,TEST_N_L mark_0835: REPORT_5: LD L,4 ; 'No more room on screen' JP ERROR_3 ; ___ mark_083A: EXPAND_1: CALL ONE_SPACE EX DE,HL ; mark_083E: WRITE_CH: LD (HL),A ; INC HL ; LD (DF_CC),HL ; DEC (IY+S_POSN_x-RAMBASE) RET ; ; ___ mark_0847: WRITE_N_L: LD C,CHARS_HORIZONTAL+1 ; $21 = 33 DEC B ; SET 0,(IY+FLAGS-RAMBASE) ; Suppress leading space JP LOC_ADDR
; THE 'LPRINT_CH' SUBROUTINE
; This routine sends a character to the ZX-Printer placing the code for the ; character in the Printer Buffer. ; Note. PR_CC contains the low byte of the buffer address. The high order byte ; is always constant. mark_0851: LPRINT_CH: CP ZX_NEWLINE ; compare to NEWLINE. JR Z,COPY_BUFF ; forward if so LD C,A ; take a copy of the character in C. LD A,(PR_CC) ; fetch print location from PR_CC AND $7F ; ignore bit 7 to form true position. CP $5C ; compare to 33rd location LD L,A ; form low-order byte. LD H,$40 ; the high-order byte is fixed. CALL Z,COPY_BUFF ; to send full buffer to ; the printer if first 32 bytes full. ; (this will reset HL to start.) LD (HL),C ; place character at location. INC L ; increment - will not cross a 256 boundary. LD (IY+PR_CC-RAMBASE),L ; update system variable PR_CC ; automatically resetting bit 7 to show that ; the buffer is not empty. RET ; return.
; THE 'COPY' COMMAND ROUTINE
; The full character-mapped screen is copied to the ZX-Printer. ; All twenty-four text/graphic lines are printed. mark_0869: COPY: ; ; check - is this $16==22 or 24? ; ;; LD D,$16 ; prepare to copy twenty four text lines. LD D,22 ; prepare to copy twenty four text lines. LD HL,(D_FILE) ; set HL to start of display file from D_FILE. INC HL ; JR COPY_D ; forward ; ___ ; A single character-mapped printer buffer is copied to the ZX-Printer. mark_0871: COPY_BUFF: LD D,1 ; prepare to copy a single text line. LD HL,PRBUFF ; set HL to start of printer buffer PRBUFF. ; both paths converge here. mark_0876: COPY_D: CALL SET_FAST PUSH BC ; *** preserve BC throughout. ; a pending character may be present ; in C from LPRINT_CH mark_087A: COPY_LOOP: PUSH HL ; save first character of line pointer. (*) XOR A ; clear accumulator. LD E,A ; set pixel line count, range 0-7, to zero. ; this inner loop deals with each horizontal pixel line. mark_087D: COPY_TIME: OUT (IO_PORT_PRINTER),A ; bit 2 reset starts the printer motor ; with an inactive stylus - bit 7 reset. POP HL ; pick up first character of line pointer (*) ; on inner loop. mark_0880: COPY_BRK: CALL BREAK_1 JR C,COPY_CONT ; forward with no keypress to COPY_CONT ; else A will hold 11111111 0 RRA ; 0111 1111 OUT (IO_PORT_PRINTER),A ; stop ZX printer motor, de-activate stylus. mark_0888: REPORT_D2: RST _ERROR_1 DEFB $0C ; Error Report: BREAK - CONT repeats ; ___ mark_088A: COPY_CONT: IN A,(IO_PORT_PRINTER) ; read from printer port. ADD A,A ; test bit 6 and 7 JP M,COPY_END ; jump forward with no printer to COPY_END JR NC,COPY_BRK ; back if stylus not in position to COPY_BRK PUSH HL ; save first character of line pointer (*) PUSH DE ; ** preserve character line and pixel line. LD A,D ; text line count to A? CP 2 ; sets carry if last line. SBC A,A ; now $FF if last line else zero. ; now cleverly prepare a printer control mask setting bit 2 (later moved to 1) ; of D to slow printer for the last two pixel lines ( E = 6 and 7) AND E ; and with pixel line offset 0-7 RLCA ; shift to left. AND E ; and again. LD D,A ; store control mask in D. mark_089C: COPY_NEXT: LD C,(HL) ; load character from screen or buffer. LD A,C ; save a copy in C for later inverse test. INC HL ; update pointer for next time. CP ZX_NEWLINE ; is character a NEWLINE ? JR Z,COPY_N_L ; forward, if so, to COPY_N_L PUSH HL ; * else preserve the character pointer. SLA A ; (?) multiply by two ADD A,A ; multiply by four ADD A,A ; multiply by eight LD H,$0F ; load H with half the address of character set. RL H ; now $1E or $1F (with carry) ADD A,E ; add byte offset 0-7 LD L,A ; now HL addresses character source byte RL C ; test character, setting carry if inverse. SBC A,A ; accumulator now $00 if normal, $FF if inverse. XOR (HL) ; combine with bit pattern at end or ROM. LD C,A ; transfer the byte to C. LD B,8 ; count eight bits to output. mark_08B5: COPY_BITS: LD A,D ; fetch speed control mask from D. RLC C ; rotate a bit from output byte to carry. RRA ; pick up in bit 7, speed bit to bit 1 LD H,A ; store aligned mask in H register. mark_08BA: COPY_WAIT: IN A,(IO_PORT_PRINTER) ; read the printer port RRA ; test for alignment signal from encoder. JR NC,COPY_WAIT ; loop if not present to COPY_WAIT LD A,H ; control byte to A. OUT (IO_PORT_PRINTER),A ; and output to printer port. DJNZ COPY_BITS ; loop for all eight bits to COPY_BITS POP HL ; * restore character pointer. JR COPY_NEXT ; back for adjacent character line to COPY_NEXT ; ___ ; A NEWLINE has been encountered either following a text line or as the ; first character of the screen or printer line. mark_08C7: COPY_N_L: IN A,(IO_PORT_PRINTER) ; read printer port. RRA ; wait for encoder signal. JR NC,COPY_N_L ; loop back if not to COPY_N_L LD A,D ; transfer speed mask to A. RRCA ; rotate speed bit to bit 1. ; bit 7, stylus control is reset. OUT (IO_PORT_PRINTER),A ; set the printer speed. POP DE ; ** restore character line and pixel line. INC E ; increment pixel line 0-7. BIT 3,E ; test if value eight reached. JR Z,COPY_TIME ; back if not ; eight pixel lines, a text line have been completed. POP BC ; lose the now redundant first character ; pointer DEC D ; decrease text line count. JR NZ,COPY_LOOP ; back if not zero LD A,$04 ; stop the already slowed printer motor. OUT (IO_PORT_PRINTER),A ; output to printer port. mark_08DE: COPY_END: CALL SLOW_FAST POP BC ; *** restore preserved BC.
; THE 'CLEAR PRINTER BUFFER' SUBROUTINE
; This subroutine sets 32 bytes of the printer buffer to zero (space) and ; the 33rd character is set to a NEWLINE. ; This occurs after the printer buffer is sent to the printer but in addition ; after the 24 lines of the screen are sent to the printer. ; Note. This is a logic error as the last operation does not involve the ; buffer at all. Logically one should be able to use ; 10 LPRINT "HELLO "; ; 20 COPY ; 30 LPRINT ; "WORLD" ; and expect to see the entire greeting emerge from the printer. ; Surprisingly this logic error was never discovered and although one can argue ; if the above is a bug, the repetition of this error on the Spectrum was most ; definitely a bug. ; Since the printer buffer is fixed at the end of the system variables, and ; the print position is in the range $3C - $5C, then bit 7 of the system ; variable is set to show the buffer is empty and automatically reset when ; the variable is updated with any print position - neat. mark_08E2: CLEAR_PRB: LD HL,PRBUFF_END ; address fixed end of PRBUFF LD (HL),ZX_NEWLINE ; place a newline at last position. LD B,32 ; prepare to blank 32 preceding characters. ; ; NB the printer is fixed at 32 characters, maybe it can be tweaked ??? ; mark_08E9: PRB_BYTES: DEC HL ; decrement address - could be DEC L. LD (HL),0 ; place a zero byte. DJNZ PRB_BYTES ; loop for all thirty-two LD A,L ; fetch character print position. SET 7,A ; signal the printer buffer is clear. LD (PR_CC),A ; update one-byte system variable PR_CC RET ; return.
; THE 'PRINT AT' SUBROUTINE
; ; ; mark_08F5: PRINT_AT: LD A,CHARS_VERTICAL-1 ; originally 23 SUB B ; JR C,WRONG_VAL mark_08FA: TEST_VAL: CP (IY+DF_SZ-RAMBASE) JP C,REPORT_5 INC A ; LD B,A ; LD A,CHARS_HORIZONTAL-1 ; originally 31 SUB C ; mark_0905: WRONG_VAL: JP C,REPORT_B ADD A,2 ; LD C,A ; mark_090B: SET_FIELD: BIT 1,(IY+FLAGS-RAMBASE) ; Is printer in use? JR Z,LOC_ADDR LD A,$5D ; SUB C ; LD (PR_CC),A ; RET ;
; THE 'LOCATE ADDRESS' ROUTINE
; ; I'm guessing this locates the address of a character at X,Y ; on the screen, with 0,0 being on the bottom left? ; S_POSN_x equ $4039 ; S_POSN_y equ $403A ; so when BC is stored there, B is Y and C is X ; mark_0918: LOC_ADDR: LD (S_POSN),BC ; LD HL,(VARS) ; LD D,C ; LD A,CHARS_HORIZONTAL+2 ; $22 == 34 originally. SUB C ; LD C,A ; LD A,ZX_NEWLINE ; INC B ; mark_0927: LOOK_BACK: DEC HL ; CP (HL) ; JR NZ,LOOK_BACK DJNZ LOOK_BACK INC HL ; CPIR ; DEC HL ; LD (DF_CC),HL ; SCF ; Set Carry Flag RET PO ; DEC D ; RET Z ; PUSH BC ; CALL MAKE_ROOM POP BC ; LD B,C ; LD H,D ; HL := DE LD L,E ; mark_0940: EXPAND_2: ; ; Writes B spaces to HL-- ; LD (HL),ZX_SPACE ; DEC HL ; DJNZ EXPAND_2 EX DE,HL ; restore HL INC HL ; LD (DF_CC),HL ; RET ;
; THE 'EXPAND TOKENS' SUBROUTINE
mark_094B: TOKENS: PUSH AF ; CALL TOKEN_ADD JR NC,ALL_CHARS BIT 0,(IY+FLAGS-RAMBASE) ; Leading space if set JR NZ,ALL_CHARS XOR A ; A = 0 = ZX_SPACE RST _PRINT_A mark_0959: ALL_CHARS: LD A,(BC) ; AND $3F ; truncate to printable values ??? RST _PRINT_A LD A,(BC) ; INC BC ; ADD A,A ; JR NC,ALL_CHARS POP BC ; BIT 7,B ; RET Z ; CP ZX_COMMA ; $1A == 26 JR Z,TRAIL_SP CP ZX_S ; $38 == 56 RET C ; mark_096D: TRAIL_SP: XOR A ; SET 0,(IY+FLAGS-RAMBASE) ; Suppress leading space JP PRINT_SP ; ___ mark_0975: TOKEN_ADD: PUSH HL ; LD HL,TOKEN_TABLE BIT 7,A ; JR Z,TEST_HIGH AND $3F ; mark_097F: TEST_HIGH: CP $43 ; JR NC,FOUND LD B,A ; INC B ; mark_0985: WORDS: BIT 7,(HL) ; INC HL ; JR Z,WORDS DJNZ WORDS BIT 6,A ; JR NZ,COMP_FLAG CP $18 ; mark_0992: COMP_FLAG: CCF ; Complement Carry Flag mark_0993: FOUND: LD B,H ; LD C,L ; POP HL ; RET NC ; LD A,(BC) ; ADD A,$E4 ; RET ;
; THE 'ONE_SPACE' SUBROUTINE
mark_099B: ONE_SPACE: LD BC,$0001 ;
; THE 'MAKE ROOM' SUBROUTINE
; ; mark_099E: MAKE_ROOM: PUSH HL ; CALL TEST_ROOM POP HL ; CALL POINTERS LD HL,(STKEND) ; EX DE,HL ; LDDR ; Copy Bytes RET ;
; THE 'POINTERS' SUBROUTINE
mark_09AD: POINTERS: PUSH AF ; PUSH HL ; LD HL,D_FILE ; LD A,$09 ; mark_09B4: NEXT_PTR: LD E,(HL) ; INC HL ; LD D,(HL) ; EX (SP),HL ; AND A ; SBC HL,DE ; ADD HL,DE ; EX (SP),HL ; JR NC,PTR_DONE PUSH DE ; EX DE,HL ; ADD HL,BC ; EX DE,HL ; LD (HL),D ; DEC HL ; LD (HL),E ; INC HL ; POP DE ; mark_09C8: PTR_DONE: INC HL ; DEC A ; JR NZ,NEXT_PTR EX DE,HL ; POP DE ; POP AF ; AND A ; SBC HL,DE ; LD B,H ; LD C,L ; INC BC ; ADD HL,DE ; EX DE,HL ; RET ;
; THE 'LINE ADDRESS' SUBROUTINE
mark_09D8: LINE_ADDR: PUSH HL ; LD HL,USER_RAM ; LD D,H ; LD E,L ; mark_09DE: NEXT_TEST: POP BC ; CALL CP_LINES RET NC ; PUSH BC ; CALL NEXT_ONE EX DE,HL ; JR NEXT_TEST
; THE 'COMPARE LINE NUMBERS' SUBROUTINE
mark_09EA: CP_LINES: LD A,(HL) ; CP B ; RET NZ ; INC HL ; LD A,(HL) ; DEC HL ; CP C ; RET ;
; THE 'NEXT LINE OR VARIABLE' SUBROUTINE
mark_09F2: NEXT_ONE: PUSH HL ; LD A,(HL) ; CP $40 ; JR C,LINES BIT 5,A ; JR Z,NEXT_0_4 ; skip forward ADD A,A ; JP M,NEXT_PLUS_FIVE CCF ; Complement Carry Flag mark_0A01: NEXT_PLUS_FIVE: LD BC,$0005 ; JR NC,NEXT_LETT LD C,$11 ; 17 mark_0A08: NEXT_LETT: RLA ; INC HL ; LD A,(HL) ; JR NC,NEXT_LETT ; loop JR NEXT_ADD ; ___ mark_0A0F: LINES: INC HL ; mark_0A10: NEXT_0_4: INC HL ; BC = word at HL++ LD C,(HL) ; INC HL ; LD B,(HL) ; INC HL ; mark_0A15: NEXT_ADD: ADD HL,BC ; POP DE ;
; THE 'DIFFERENCE' SUBROUTINE
mark_0A17: DIFFER: AND A ; SBC HL,DE ; LD B,H ; BC := (HL-DE) LD C,L ; ADD HL,DE ; EX DE,HL ; DE := old HL ??? RET ;
; THE 'LINE_ENDS' SUBROUTINE
mark_0A1F: LINE_ENDS: LD B,(IY+DF_SZ-RAMBASE) PUSH BC ; CALL B_LINES POP BC ; DEC B ; JR B_LINES
; THE 'CLS' COMMAND ROUTINE
mark_0A2A: CLS: LD B,CHARS_VERTICAL ; number of lines to clear. $18 = 24 originally. mark_0A2C: B_LINES: RES 1,(IY+FLAGS-RAMBASE) ; Signal printer not in use LD C,CHARS_HORIZONTAL+1 ; $21 ; extra 1 is for HALT opcode ? PUSH BC ; CALL LOC_ADDR POP BC ; LD A,(RAMTOP+1) ; is RAMTOP_hi CP $4D ; JR C,COLLAPSED ; ; If RAMTOP less then 4D00, RAM less than D00 = 3.25 K, ; uses collapsed display. ; SET 7,(IY+S_POSN_y-RAMBASE) mark_0A42: CLEAR_LOC: XOR A ; prepare a space CALL PRINT_SP ; prints a space LD HL,(S_POSN) ; LD A,L ; OR H ; AND $7E ; JR NZ,CLEAR_LOC JP LOC_ADDR ; ___ mark_0A52: COLLAPSED: LD D,H ; DE := HL LD E,L ; DEC HL ; LD C,B ; LD B,0 ; Will loop 256 times LDIR ; Copy Bytes LD HL,(VARS) ;
; THE 'RECLAIMING' SUBROUTINES
mark_0A5D: RECLAIM_1: CALL DIFFER mark_0A60: RECLAIM_2: PUSH BC ; LD A,B ; CPL ; LD B,A ; LD A,C ; CPL ; LD C,A ; INC BC ; CALL POINTERS EX DE,HL ; POP HL ; ADD HL,DE ; PUSH DE ; LDIR ; Copy Bytes POP HL ; RET ;
; THE 'E_LINE NUMBER' SUBROUTINE
mark_0A73: E_LINE_NUM: LD HL,(E_LINE) ; CALL TEMP_PTR2 RST _GET_CHAR BIT 5,(IY+FLAGX-RAMBASE) RET NZ ; LD HL,MEM_0_1st ; LD (STKEND),HL ; CALL INT_TO_FP CALL FP_TO_BC JR C,NO_NUMBER ; to NO_NUMBER LD HL,-10000 ; $D8F0 ; value '-10000' ADD HL,BC ; mark_0A91: NO_NUMBER: JP C,REPORT_C ; to REPORT_C CP A ; JP SET_MIN
; THE 'REPORT AND LINE NUMBER' PRINTING SUBROUTINES
mark_0A98: OUT_NUM: PUSH DE ; PUSH HL ; XOR A ; BIT 7,B ; JR NZ,UNITS LD H,B ; HL := BC LD L,C ; LD E,$FF ; JR THOUSAND ; ___ mark_0AA5: OUT_NO: PUSH DE ; LD D,(HL) ; INC HL ; LD E,(HL) ; PUSH HL ; EX DE,HL ; LD E,ZX_SPACE ; set E to leading space. mark_0AAD: THOUSAND: LD BC,-1000 ; $FC18 ; CALL OUT_DIGIT LD BC,-100 ; $FF9C ; CALL OUT_DIGIT LD C,-10 ; $F6 ; B is already FF, so saves a byte. CALL OUT_DIGIT LD A,L ; mark_0ABF: UNITS: CALL OUT_CODE POP HL ; POP DE ; RET ;
; THE 'UNSTACK_Z' SUBROUTINE
; This subroutine is used to return early from a routine when checking syntax. ; On the ZX81 the same routines that execute commands also check the syntax ; on line entry. This enables precise placement of the error marker in a line ; that fails syntax. ; The sequence CALL SYNTAX_Z ; RET Z can be replaced by a call to this routine ; although it has not replaced every occurrence of the above two instructions. ; Even on the ZX80 this routine was not fully utilized. mark_0AC5: UNSTACK_Z: CALL SYNTAX_Z ; resets the ZERO flag if ; checking syntax. POP HL ; drop the return address. RET Z ; return to previous calling routine if ; checking syntax. JP (HL) ; else jump to the continuation address in ; the calling routine as RET would have done.
; THE 'LPRINT' COMMAND ROUTINE
; ; mark_0ACB: LPRINT: SET 1,(IY+FLAGS-RAMBASE) ; Signal printer in use
; THE 'PRINT' COMMAND ROUTINE
mark_0ACF: PRINT: LD A,(HL) ; CP ZX_NEWLINE ; JP Z,PRINT_END ; to PRINT_END mark_0AD5: PRINT_1: SUB ZX_COMMA ; $1A == 26 ADC A,$00 ; JR Z,SPACING ; to SPACING ; ; Compare with AT, ; less comma recently subtracted. ; CP ZX_AT-ZX_COMMA ; $A7 == 167 JR NZ,NOT_AT ; RST _NEXT_CHAR CALL CLASS_6 CP ZX_COMMA ; $1A = 26 JP NZ,REPORT_C ; RST _NEXT_CHAR CALL CLASS_6 CALL SYNTAX_ON RST _FP_CALC ;; DEFB __exchange ;; DEFB __end_calc ;; CALL STK_TO_BC CALL PRINT_AT JR PRINT_ON ; ___ mark_0AFA: NOT_AT: CP ZX_TAB-ZX_COMMA ; $A8 == 168 JR NZ,NOT_TAB RST _NEXT_CHAR CALL CLASS_6 CALL SYNTAX_ON CALL STK_TO_A JP NZ,REPORT_B AND $1F ; truncate to 0 to 31 characters ??? LD C,A ; BIT 1,(IY+FLAGS-RAMBASE) ; Is printer in use JR Z,TAB_TEST SUB (IY+PR_CC-RAMBASE) SET 7,A ; ADD A,$3C ; 60 CALL NC,COPY_BUFF mark_0B1E: TAB_TEST: ADD A,(IY+S_POSN_x-RAMBASE) ; screen position X CP CHARS_HORIZONTAL+1 ; 33 (characters horizontal plus newline ???) LD A,(S_POSN_y) ; screen position Y SBC A,1 ; CALL TEST_VAL SET 0,(IY+FLAGS-RAMBASE) ; sv FLAGS - Suppress leading space JR PRINT_ON ; ___ mark_0B31: NOT_TAB: CALL SCANNING CALL PRINT_STK mark_0B37: PRINT_ON: RST _GET_CHAR SUB ZX_COMMA ; $1A ADC A,0 ; JR Z,SPACING CALL CHECK_END JP PRINT_END ; ___ mark_0B44: SPACING: CALL NC,FIELD RST _NEXT_CHAR CP ZX_NEWLINE ; RET Z ; JP PRINT_1 ; ___ mark_0B4E: SYNTAX_ON: CALL SYNTAX_Z RET NZ ; POP HL ; JR PRINT_ON ; ___ mark_0B55: PRINT_STK: CALL UNSTACK_Z BIT 6,(IY+FLAGS-RAMBASE) ; Numeric or string result? CALL Z,STK_FETCH JR Z,PR_STR_4 JP PRINT_FP ; jump forward ; ___ mark_0B64: PR_STR_1: LD A,ZX_QUOTE ; $0B mark_0B66: PR_STR_2: RST _PRINT_A mark_0B67: PR_STR_3: LD DE,(X_PTR) ; mark_0B6B: PR_STR_4: LD A,B ; OR C ; DEC BC ; RET Z ; LD A,(DE) ; INC DE ; LD (X_PTR),DE ; BIT 6,A ; JR Z,PR_STR_2 CP $C0 ; JR Z,PR_STR_1 PUSH BC ; CALL TOKENS POP BC ; JR PR_STR_3 ; ___ mark_0B84: PRINT_END: CALL UNSTACK_Z LD A,ZX_NEWLINE ; RST _PRINT_A RET ; ; ___ mark_0B8B: FIELD: CALL UNSTACK_Z SET 0,(IY+FLAGS-RAMBASE) ; Suppress leading space XOR A ; RST _PRINT_A LD BC,(S_POSN) ; LD A,C ; BIT 1,(IY+FLAGS-RAMBASE) ; Is printer in use JR Z,CENTRE LD A,$5D ; SUB (IY+PR_CC-RAMBASE) mark_0BA4: CENTRE: LD C,$11 ; CP C ; JR NC,RIGHT LD C,$01 ; mark_0BAB: RIGHT: CALL SET_FIELD RET ;
; THE 'PLOT AND UNPLOT' COMMAND ROUTINES
mark_0BAF: PLOT_UNPLOT: ; ; Of the 24 lines, only top 22 ar used for plotting. ; CALL STK_TO_BC LD (COORDS_x),BC ; ;; LD A,$2B ; originally $2B == 32+11 = 43 = 2*22-1 LD A,2*(CHARS_VERTICAL-2)-1 ; SUB B ; JP C,REPORT_B LD B,A ; LD A,$01 ; SRA B ; JR NC,COLUMNS LD A,$04 ; mark_0BC5: COLUMNS: SRA C ; JR NC,FIND_ADDR RLCA ; mark_0BCA: FIND_ADDR: PUSH AF ; CALL PRINT_AT LD A,(HL) ; RLCA ; CP ZX_BRACKET_LEFT ; $10 JR NC,TABLE_PTR RRCA ; JR NC,SQ_SAVED XOR $8F ; mark_0BD9: SQ_SAVED: LD B,A ; mark_0BDA: TABLE_PTR: LD DE,P_UNPLOT ; Address: P_UNPLOT LD A,(T_ADDR) ; get T_ADDR_lo SUB E ; JP M,PLOT POP AF ; CPL ; AND B ; JR UNPLOT ; ___ mark_0BE9: PLOT: POP AF ; OR B ; mark_0BEB: UNPLOT: CP 8 ; Only apply to graphic characters (0 to 7) JR C,PLOT_END XOR $8F ; binary 1000 1111 mark_0BF1: PLOT_END: EXX ; RST _PRINT_A EXX ; RET ;
; THE 'STACK_TO_BC' SUBROUTINE
mark_0BF5: STK_TO_BC: CALL STK_TO_A LD B,A ; PUSH BC ; CALL STK_TO_A LD E,C ; POP BC ; LD D,C ; LD C,A ; RET ;
; THE 'STACK_TO_A' SUBROUTINE
mark_0C02: STK_TO_A: CALL FP_TO_A JP C,REPORT_B LD C,$01 ; RET Z ; LD C,$FF ; RET ;
; THE 'SCROLL' SUBROUTINE
mark_0C0E: SCROLL: LD B,(IY+DF_SZ-RAMBASE) LD C,CHARS_HORIZONTAL+1 ; CALL LOC_ADDR CALL ONE_SPACE LD A,(HL) ; LD (DE),A ; INC (IY+S_POSN_y-RAMBASE) LD HL,(D_FILE) ; INC HL ; LD D,H ; LD E,L ; CPIR ; JP RECLAIM_1
; THE 'SYNTAX' TABLES
; i) The Offset table mark_0C29: offset_t: DEFB P_LPRINT - $ ; 8B offset DEFB P_LLIST - $ ; 8D offset DEFB P_STOP - $ ; 2D offset DEFB P_SLOW - $ ; 7F offset DEFB P_FAST - $ ; 81 offset DEFB P_NEW - $ ; 49 offset DEFB P_SCROLL - $ ; 75 offset DEFB P_CONT - $ ; 5F offset DEFB P_DIM - $ ; 40 offset DEFB P_REM - $ ; 42 offset DEFB P_FOR - $ ; 2B offset DEFB P_GOTO - $ ; 17 offset DEFB P_GOSUB - $ ; 1F offset DEFB P_INPUT - $ ; 37 offset DEFB P_LOAD - $ ; 52 offset DEFB P_LIST - $ ; 45 offset DEFB P_LET - $ ; 0F offset DEFB P_PAUSE - $ ; 6D offset DEFB P_NEXT - $ ; 2B offset DEFB P_POKE - $ ; 44 offset DEFB P_PRINT - $ ; 2D offset DEFB P_PLOT - $ ; 5A offset DEFB P_RUN - $ ; 3B offset DEFB P_SAVE - $ ; 4C offset DEFB P_RAND - $ ; 45 offset DEFB P_IF - $ ; 0D offset DEFB P_CLS - $ ; 52 offset DEFB P_UNPLOT - $ ; 5A offset DEFB P_CLEAR - $ ; 4D offset DEFB P_RETURN - $ ; 15 offset DEFB P_COPY - $ ; 6A offset
; ii) The parameter table. mark_0C48: P_LET: DEFB _CLASS_01 ; A variable is required. DEFB ZX_EQUAL ; Separator: '=' DEFB _CLASS_02 ; An expression, numeric or string, ; must follow. mark_0C4B: P_GOTO: DEFB _CLASS_06 ; A numeric expression must follow. DEFB _CLASS_00 ; No further operands. DEFW GOTO mark_0C4F: P_IF: DEFB _CLASS_06 ; A numeric expression must follow. DEFB ZX_THEN ; Separator: 'THEN' DEFB _CLASS_05 ; Variable syntax checked entirely ; by routine. DEFW IF mark_0C54: P_GOSUB: DEFB _CLASS_06 ; A numeric expression must follow. DEFB _CLASS_00 ; No further operands. DEFW GOSUB mark_0C58: P_STOP: DEFB _CLASS_00 ; No further operands. DEFW STOP mark_0C5B: P_RETURN: DEFB _CLASS_00 ; No further operands. DEFW RETURN mark_0C5E: P_FOR: DEFB _CLASS_04 ; A single character variable must ; follow. DEFB ZX_EQUAL ; Separator: '=' DEFB _CLASS_06 ; A numeric expression must follow. DEFB ZX_TO ; Separator: 'TO' DEFB _CLASS_06 ; A numeric expression must follow. DEFB _CLASS_05 ; Variable syntax checked entirely ; by routine. DEFW FOR mark_0C66: P_NEXT: DEFB _CLASS_04 ; A single character variable must ; follow. DEFB _CLASS_00 ; No further operands. DEFW NEXT mark_0C6A: P_PRINT: DEFB _CLASS_05 ; Variable syntax checked entirely ; by routine. DEFW PRINT ; not LPRINT ??? mark_0C6D: P_INPUT: DEFB _CLASS_01 ; A variable is required. DEFB _CLASS_00 ; No further operands. DEFW INPUT mark_0C71: P_DIM: DEFB _CLASS_05 ; Variable syntax checked entirely ; by routine. DEFW DIM mark_0C74: P_REM: DEFB _CLASS_05 ; Variable syntax checked entirely ; by routine. DEFW REM mark_0C77: P_NEW: DEFB _CLASS_00 ; No further operands. DEFW NEW mark_0C7A: P_RUN: DEFB _CLASS_03 ; A numeric expression may follow ; else default to zero. DEFW RUN mark_0C7D: P_LIST: DEFB _CLASS_03 ; A numeric expression may follow ; else default to zero. DEFW LIST mark_0C80: P_POKE: DEFB _CLASS_06 ; A numeric expression must follow. DEFB ZX_COMMA ; Separator: ',' DEFB _CLASS_06 ; A numeric expression must follow. DEFB _CLASS_00 ; No further operands. DEFW POKE mark_0C86: P_RAND: DEFB _CLASS_03 ; A numeric expression may follow ; else default to zero. DEFW RAND mark_0C89: P_LOAD: DEFB _CLASS_05 ; Variable syntax checked entirely ; by routine. DEFW LOAD mark_0C8C: P_SAVE: DEFB _CLASS_05 ; Variable syntax checked entirely ; by routine. DEFW SAVE mark_0C8F: P_CONT: DEFB _CLASS_00 ; No further operands. DEFW CONT mark_0C92: P_CLEAR: DEFB _CLASS_00 ; No further operands. DEFW CLEAR mark_0C95: P_CLS: DEFB _CLASS_00 ; No further operands. DEFW CLS mark_0C98: P_PLOT: DEFB _CLASS_06 ; A numeric expression must follow. DEFB ZX_COMMA ; Separator: ',' DEFB _CLASS_06 ; A numeric expression must follow. DEFB _CLASS_00 ; No further operands. DEFW PLOT_UNPLOT mark_0C9E: P_UNPLOT: DEFB _CLASS_06 ; A numeric expression must follow. DEFB ZX_COMMA ; Separator: ',' DEFB _CLASS_06 ; A numeric expression must follow. DEFB _CLASS_00 ; No further operands. DEFW PLOT_UNPLOT mark_0CA4: P_SCROLL: DEFB _CLASS_00 ; No further operands. DEFW SCROLL mark_0CA7: P_PAUSE: DEFB _CLASS_06 ; A numeric expression must follow. DEFB _CLASS_00 ; No further operands. DEFW PAUSE mark_0CAB: P_SLOW: DEFB _CLASS_00 ; No further operands. DEFW SLOW mark_0CAE: P_FAST: DEFB _CLASS_00 ; No further operands. DEFW FAST mark_0CB1: P_COPY: DEFB _CLASS_00 ; No further operands. DEFW COPY mark_0CB4: P_LPRINT: DEFB _CLASS_05 ; Variable syntax checked entirely ; by routine. DEFW LPRINT mark_0CB7: P_LLIST: DEFB _CLASS_03 ; A numeric expression may follow ; else default to zero. DEFW LLIST
; THE 'LINE SCANNING' ROUTINE
mark_0CBA: LINE_SCAN: LD (IY+FLAGS-RAMBASE),1 CALL E_LINE_NUM mark_0CC1: LINE_RUN: CALL SET_MIN LD HL,ERR_NR ; LD (HL),$FF ; LD HL,FLAGX ; BIT 5,(HL) ; JR Z,LINE_NULL CP $E3 ; 'STOP' ? LD A,(HL) ; JP NZ,INPUT_REP CALL SYNTAX_Z RET Z ; RST _ERROR_1 DEFB $0C ; Error Report: BREAK - CONT repeats
; THE 'STOP' COMMAND ROUTINE
; ; mark_0CDC: STOP: RST _ERROR_1 DEFB $08 ; Error Report: STOP statement ; ___ ; the interpretation of a line continues with a check for just spaces ; followed by a carriage return. ; The IF command also branches here with a true value to execute the ; statement after the THEN but the statement can be null so ; 10 IF 1 = 1 THEN ; passes syntax (on all ZX computers). mark_0CDE: LINE_NULL: RST _GET_CHAR LD B,$00 ; prepare to index - early. CP ZX_NEWLINE ; compare to NEWLINE. RET Z ; return if so. LD C,A ; transfer character to C. RST _NEXT_CHAR ; advances. LD A,C ; character to A SUB $E1 ; subtract 'LPRINT' - lowest command. JR C,REPORT_C2 ; forward if less LD C,A ; reduced token to C LD HL,offset_t ; set HL to address of offset table. ADD HL,BC ; index into offset table. LD C,(HL) ; fetch offset ADD HL,BC ; index into parameter table. JR GET_PARAM ; ___ mark_0CF4: SCAN_LOOP: LD HL,(T_ADDR) ; ; -> Entry Point to Scanning Loop mark_0CF7: GET_PARAM: LD A,(HL) ; INC HL ; LD (T_ADDR),HL ; LD BC,SCAN_LOOP PUSH BC ; is pushed on machine stack. LD C,A ; CP ZX_QUOTE ; $0B JR NC,SEPARATOR LD HL,class_tbl ; class_tbl - the address of the class table. LD B,$00 ; ADD HL,BC ; LD C,(HL) ; ADD HL,BC ; PUSH HL ; RST _GET_CHAR RET ; indirect jump to class routine and ; by subsequent RET to SCAN_LOOP.
; THE 'SEPARATOR' ROUTINE
mark_0D10: SEPARATOR: RST _GET_CHAR CP C ; JR NZ,REPORT_C2 ; 'Nonsense in BASIC' RST _NEXT_CHAR RET ; return
; THE 'COMMAND CLASS' TABLE
; mark_0D16: class_tbl: DEFB CLASS_0 - $ ; 17 offset to; Address: CLASS_0 DEFB CLASS_1 - $ ; 25 offset to; Address: CLASS_1 DEFB CLASS_2 - $ ; 53 offset to; Address: CLASS_2 DEFB CLASS_3 - $ ; 0F offset to; Address: CLASS_3 DEFB CLASS_4 - $ ; 6B offset to; Address: CLASS_4 DEFB CLASS_5 - $ ; 13 offset to; Address: CLASS_5 DEFB CLASS_6 - $ ; 76 offset to; Address: CLASS_6
; THE 'CHECK END' SUBROUTINE
; Check for end of statement and that no spurious characters occur after ; a correctly parsed statement. Since only one statement is allowed on each ; line, the only character that may follow a statement is a NEWLINE. ; mark_0D1D: CHECK_END: CALL SYNTAX_Z RET NZ ; return in runtime. POP BC ; else drop return address. mark_0D22: CHECK_2: LD A,(HL) ; fetch character. CP ZX_NEWLINE ; compare to NEWLINE. RET Z ; return if so. mark_0D26: REPORT_C2: JR REPORT_C ; 'Nonsense in BASIC'
; COMMAND CLASSES 03, 00, 05
mark_0D28: CLASS_3: CP ZX_NEWLINE ; CALL NUMBER_TO_STK mark_0D2D: CLASS_0: CP A ; mark_0D2E: CLASS_5: POP BC ; CALL Z,CHECK_END EX DE,HL ; LD HL,(T_ADDR) ; LD C,(HL) ; INC HL ; LD B,(HL) ; EX DE,HL ; mark_0D3A: CLASS_END: PUSH BC ; RET ;
; COMMAND CLASSES 01, 02, 04, 06
mark_0D3C: CLASS_1: CALL LOOK_VARS mark_0D3F: CLASS_4_2: LD (IY+FLAGX-RAMBASE),$00 JR NC,SET_STK SET 1,(IY+FLAGX-RAMBASE) JR NZ,SET_STRLN mark_0D4B: REPORT_2: RST _ERROR_1 DEFB $01 ; Error Report: Variable not found ; ___ mark_0D4D: SET_STK: CALL Z,STK_VAR BIT 6,(IY+FLAGS-RAMBASE) ; Numeric or string result? JR NZ,SET_STRLN XOR A ; CALL SYNTAX_Z CALL NZ,STK_FETCH LD HL,FLAGX ; OR (HL) ; LD (HL),A ; EX DE,HL ; mark_0D63: SET_STRLN: LD (STRLEN),BC ; LD (DEST),HL ; ; THE 'REM' COMMAND ROUTINE mark_0D6A: REM: RET ; ; ___ mark_0D6B: CLASS_2: POP BC ; LD A,(FLAGS) ; sv mark_0D6F: INPUT_REP: PUSH AF ; CALL SCANNING POP AF ; LD BC,LET ; Address: LET LD D,(IY+FLAGS-RAMBASE) XOR D ; AND $40 ; JR NZ,REPORT_C ; to REPORT_C BIT 7,D ; JR NZ,CLASS_END ; to CLASS_END JR CHECK_2 ; to CHECK_2 ; ___ mark_0D85: CLASS_4: CALL LOOK_VARS PUSH AF ; LD A,C ; OR $9F ; INC A ; JR NZ,REPORT_C ; to REPORT_C POP AF ; JR CLASS_4_2 ; to CLASS_4_2 ; ___ mark_0D92: CLASS_6: CALL SCANNING BIT 6,(IY+FLAGS-RAMBASE) ; Numeric or string result? RET NZ ; mark_0D9A: REPORT_C: RST _ERROR_1 DEFB $0B ; Error Report: Nonsense in BASIC
; THE 'NUMBER TO STACK' SUBROUTINE
; ; mark_0D9C: NUMBER_TO_STK: JR NZ,CLASS_6 ; back to CLASS_6 with a non-zero number. CALL SYNTAX_Z RET Z ; return if checking syntax. ; in runtime a zero default is placed on the calculator stack. RST _FP_CALC ;; DEFB __stk_zero ;; DEFB __end_calc ;; RET ; return.
; THE 'SYNTAX_Z' SUBROUTINE
; This routine returns with zero flag set if checking syntax. ; Calling this routine uses three instruction bytes compared to four if the ; bit test is implemented inline. mark_0DA6: SYNTAX_Z: BIT 7,(IY+FLAGS-RAMBASE) ; checking syntax only? RET ; return.
; THE 'IF' COMMAND ROUTINE
; In runtime, the class routines have evaluated the test expression and ; the result, true or false, is on the stack. mark_0DAB: IF: CALL SYNTAX_Z JR Z,IF_END ; forward if checking syntax ; else delete the Boolean value on the calculator stack. RST _FP_CALC ;; DEFB __delete ;; DEFB __end_calc ;; ; register DE points to exponent of floating point value. LD A,(DE) ; fetch exponent. AND A ; test for zero - FALSE. RET Z ; return if so. mark_0DB6: IF_END: JP LINE_NULL ; jump back
; THE 'FOR' COMMAND ROUTINE
; ; mark_0DB9: FOR: CP ZX_STEP ; is current character 'STEP' ? JR NZ,F_USE_ONE ; forward if not RST _NEXT_CHAR CALL CLASS_6 ; stacks the number CALL CHECK_END JR F_REORDER ; forward to F_REORDER ; ___ mark_0DC6: F_USE_ONE: CALL CHECK_END RST _FP_CALC ;; DEFB __stk_one ;; DEFB __end_calc ;; mark_0DCC: F_REORDER: RST _FP_CALC ;; v, l, s. DEFB __st_mem_0 ;; v, l, s. DEFB __delete ;; v, l. DEFB __exchange ;; l, v. DEFB __get_mem_0 ;; l, v, s. DEFB __exchange ;; l, s, v. DEFB __end_calc ;; l, s, v. CALL LET LD (MEM),HL ; set MEM to address variable. DEC HL ; point to letter. LD A,(HL) ; SET 7,(HL) ; LD BC,$0006 ; ADD HL,BC ; RLCA ; JR C,F_LMT_STP SLA C ; CALL MAKE_ROOM INC HL ; mark_0DEA: F_LMT_STP: PUSH HL ; RST _FP_CALC ;; DEFB __delete ;; DEFB __delete ;; DEFB __end_calc ;; POP HL ; EX DE,HL ; LD C,$0A ; ten bytes to be moved. LDIR ; copy bytes LD HL,(PPC) ; set HL to system variable PPC current line. EX DE,HL ; transfer to DE, variable pointer to HL. INC DE ; loop start will be this line + 1 at least. LD (HL),E ; INC HL ; LD (HL),D ; CALL NEXT_LOOP ; considers an initial pass. RET NC ; return if possible. ; else program continues from point following matching NEXT. BIT 7,(IY+PPC_hi-RAMBASE) RET NZ ; return if over 32767 ??? LD B,(IY+STRLEN_lo-RAMBASE) ; fetch variable name from STRLEN_lo RES 6,B ; make a true letter. LD HL,(NXTLIN) ; set HL from NXTLIN ; now enter a loop to look for matching next. mark_0E0E: NXTLIN_NO: LD A,(HL) ; fetch high byte of line number. AND $C0 ; mask off low bits $3F JR NZ,FOR_END ; forward at end of program PUSH BC ; save letter CALL NEXT_ONE ; finds next line. POP BC ; restore letter INC HL ; step past low byte INC HL ; past the INC HL ; line length. CALL TEMP_PTR1 ; sets CH_ADD RST _GET_CHAR CP ZX_NEXT ; EX DE,HL ; next line to HL. JR NZ,NXTLIN_NO ; back with no match ; EX DE,HL ; restore pointer. RST _NEXT_CHAR ; advances and gets letter in A. EX DE,HL ; save pointer CP B ; compare to variable name. JR NZ,NXTLIN_NO ; back with mismatch mark_0E2A: FOR_END: LD (NXTLIN),HL ; update system variable NXTLIN RET ; return.
; THE 'NEXT' COMMAND ROUTINE
; ; mark_0E2E: NEXT: BIT 1,(IY+FLAGX-RAMBASE) JP NZ,REPORT_2 LD HL,(DEST) BIT 7,(HL) JR Z,REPORT_1 INC HL ; LD (MEM),HL ; RST _FP_CALC ;; DEFB __get_mem_0 ;; DEFB __get_mem_2 ;; DEFB __addition ;; DEFB __st_mem_0 ;; DEFB __delete ;; DEFB __end_calc ;; CALL NEXT_LOOP RET C ; LD HL,(MEM) ; LD DE,$000F ; ADD HL,DE ; LD E,(HL) ; INC HL ; LD D,(HL) ; EX DE,HL ; JR GOTO_2 ; ___ mark_0E58: REPORT_1: RST _ERROR_1 DEFB $00 ; Error Report: NEXT without FOR
; THE 'NEXT_LOOP' SUBROUTINE
; ; mark_0E5A: NEXT_LOOP: RST _FP_CALC ;; DEFB __get_mem_1 ;; DEFB __get_mem_0 ;; DEFB __get_mem_2 ;; DEFB __less_0 ;; DEFB __jump_true ;; DEFB LMT_V_VAL - $ ;; DEFB __exchange ;; mark_0E62: LMT_V_VAL: DEFB __subtract ;; DEFB __greater_0 ;; DEFB __jump_true ;; DEFB IMPOSS - $ ;; DEFB __end_calc ;; AND A ; clear carry flag RET ; return. ; ___ mark_0E69: IMPOSS: DEFB __end_calc ;; SCF ; set carry flag RET ; return.
; THE 'RAND' COMMAND ROUTINE
; The keyword was 'RANDOMISE' on the ZX80, is 'RAND' here on the ZX81 and ; becomes 'RANDOMIZE' on the ZX Spectrum. ; In all invocations the procedure is the same - to set the SEED system variable ; with a supplied integer value or to use a time-based value if no number, or ; zero, is supplied. mark_0E6C: RAND: CALL FIND_INT LD A,B ; test value OR C ; for zero JR NZ,SET_SEED ; forward if not zero LD BC,(FRAMES) ; fetch value of FRAMES system variable. mark_0E77: SET_SEED: LD (SEED),BC ; update the SEED system variable. RET ; return.
; THE 'CONT' COMMAND ROUTINE
; Another abbreviated command. ROM space was really tight. ; CONTINUE at the line number that was set when break was pressed. ; Sometimes the current line, sometimes the next line. mark_0E7C: CONT: LD HL,(OLDPPC) ; set HL from system variable OLDPPC JR GOTO_2 ; forward
; THE 'GOTO' COMMAND ROUTINE
; This token also suffered from the shortage of room and there is no space ; getween GO and TO as there is on the ZX80 and ZX Spectrum. The same also ; applies to the GOSUB keyword. mark_0E81: GOTO: CALL FIND_INT LD H,B ; LD L,C ; mark_0E86: GOTO_2: LD A,H ; CP $F0 ; ZX_LIST ??? JR NC,REPORT_B CALL LINE_ADDR LD (NXTLIN),HL ; sv RET ;
; THE 'POKE' COMMAND ROUTINE
mark_0E92: POKE: CALL FP_TO_A JR C,REPORT_B ; forward, with overflow JR Z,POKE_SAVE ; forward, if positive NEG ; negate mark_0E9B: POKE_SAVE: PUSH AF ; preserve value. CALL FIND_INT ; gets address in BC ; invoking the error routine with overflow ; or a negative number. POP AF ; restore value. ; Note. the next two instructions are legacy code from the ZX80 and ; inappropriate here. BIT 7,(IY+ERR_NR-RAMBASE) ; test ERR_NR - is it still $FF ? RET Z ; return with error. LD (BC),A ; update the address contents. RET ; return.
; THE 'FIND INTEGER' SUBROUTINE
mark_0EA7: FIND_INT: CALL FP_TO_BC JR C,REPORT_B ; forward with overflow RET Z ; return if positive (0-65535). mark_0EAD: REPORT_B: RST _ERROR_1 DEFB $0A ; Error Report: Integer out of range ; ; Seems stupid, $0A is 10 but the ERROR_CODE_INTEGER_OUT_OF_RANGE is 11 ; maybe gets incremented ???
; THE 'RUN' COMMAND ROUTINE
mark_0EAF: RUN: CALL GOTO JP CLEAR
; THE 'GOSUB' COMMAND ROUTINE
mark_0EB5: GOSUB: LD HL,(PPC) ; INC HL ; EX (SP),HL ; PUSH HL ; LD (ERR_SP),SP ; set the error stack pointer - ERR_SP CALL GOTO LD BC,6 ;
; THE 'TEST ROOM' SUBROUTINE
; ; checks ther is room for 36 bytes on the stack ; mark_0EC5: TEST_ROOM: LD HL,(STKEND) ; ADD HL,BC ; HL = STKEND + BC JR C,REPORT_4 EX DE,HL ; DE = STKEND + BC LD HL,$0024 ; 36 decimal ADD HL,DE ; HL = 36 + STKEND + BC SBC HL,SP ; HL = 36 + STKEND + BC - SP RET C ; mark_0ED3: REPORT_4: LD L,3 ; JP ERROR_3
; THE 'RETURN' COMMAND ROUTINE
mark_0ED8: RETURN: POP HL ; EX (SP),HL ; LD A,H ; CP $3E ; JR Z,REPORT_7 LD (ERR_SP),SP ; JR GOTO_2 ; back ; ___ mark_0EE5: REPORT_7: EX (SP),HL ; PUSH HL ; RST _ERROR_1 DEFB 6 ; Error Report: RETURN without GOSUB ; ; Contradicts BASIC manual: ; 7 is ERROR_CODE_RETURN_WITHOUT_GOSUB ; 6 is ERROR_CODE_ARITHMETIC_OVERFLOW ;
; THE 'INPUT' COMMAND ROUTINE
mark_0EE9: INPUT: BIT 7,(IY+PPC_hi-RAMBASE) JR NZ,REPORT_8 ; to REPORT_8 CALL X_TEMP LD HL,FLAGX ; SET 5,(HL) ; RES 6,(HL) ; LD A,(FLAGS) ; AND $40 ; 64 LD BC,2 ; JR NZ,PROMPT ; to PROMPT LD C,$04 ; mark_0F05: PROMPT: OR (HL) ; LD (HL),A ; RST _BC_SPACES LD (HL),ZX_NEWLINE LD A,C ; RRCA ; RRCA ; JR C,ENTER_CUR LD A,$0B ; ZX_QUOTE ??? LD (DE),A ; DEC HL ; LD (HL),A ; mark_0F14: ENTER_CUR: DEC HL ; LD (HL),ZX_CURSOR ; LD HL,(S_POSN) ; LD (T_ADDR),HL ; POP HL ; JP LOWER ; ___ mark_0F21: REPORT_8: RST _ERROR_1 DEFB 7 ; Error Report: End of file
; THE 'PAUSE' COMMAND ROUTINE
mark_0F23: FAST: CALL SET_FAST RES 6,(IY+CDFLAG-RAMBASE) RET ; return.
; THE 'SLOW' COMMAND ROUTINE
mark_0F2B: SLOW: SET 6,(IY+CDFLAG-RAMBASE) JP SLOW_FAST
; THE 'PAUSE' COMMAND ROUTINE
mark_0F32: PAUSE: CALL FIND_INT CALL SET_FAST LD H,B ; LD L,C ; CALL DISPLAY_P LD (IY+FRAMES_hi-RAMBASE),$FF CALL SLOW_FAST JR DEBOUNCE
; THE 'BREAK' SUBROUTINE
mark_0F46: BREAK_1: LD A,$7F ; read port $7FFE - keys B,N,M,.,SPACE. IN A,(IO_PORT_KEYBOARD_RD) ; RRA ; carry will be set if space not pressed.
; THE 'DEBOUNCE' SUBROUTINE
mark_0F4B: DEBOUNCE: RES 0,(IY+CDFLAG-RAMBASE) ; update LD A,$FF ; LD (DEBOUNCE_VAR),A ; update RET ; return.
; THE 'SCANNING' SUBROUTINE
; This recursive routine is where the ZX81 gets its power. ; Provided there is enough memory it can evaluate ; an expression of unlimited complexity. ; Note. there is no unary plus so, as on the ZX80, PRINT +1 gives a syntax error. ; PRINT +1 works on the Spectrum but so too does PRINT + "STRING". mark_0F55: SCANNING: RST _GET_CHAR LD B,0 ; set B register to zero. PUSH BC ; stack zero as a priority end-marker. mark_0F59: S_LOOP_1: CP ZX_RND JR NZ,S_TEST_PI ; forward, if not, to S_TEST_PI
; THE 'RND' FUNCTION
RND: CALL SYNTAX_Z JR Z,S_JPI_END ; forward if checking syntax to S_JPI_END LD BC,(SEED) ; sv CALL STACK_BC RST _FP_CALC ;; DEFB __stk_one ;; DEFB __addition ;; DEFB __stk_data ;; DEFB $37 ;;Exponent: $87, Bytes: 1 DEFB $16 ;;(+00,+00,+00) DEFB __multiply ;; DEFB __stk_data ;; DEFB $80 ;;Bytes: 3 DEFB $41 ;;Exponent $91 DEFB $00,$00,$80 ;;(+00) DEFB __n_mod_m ;; DEFB __delete ;; DEFB __stk_one ;; DEFB __subtract ;; DEFB __duplicate ;; DEFB __end_calc ;; CALL FP_TO_BC LD (SEED),BC ; update the SEED system variable. LD A,(HL) ; HL addresses the exponent of the last value. AND A ; test for zero JR Z,S_JPI_END ; forward, if so SUB $10 ; else reduce exponent by sixteen LD (HL),A ; thus dividing by 65536 for last value. mark_0F8A: S_JPI_END: JR S_PI_END ; forward ; ___ mark_0F8C: S_TEST_PI: CP ZX_PI ; the 'PI' character JR NZ,S_TST_INK ; forward, if not
; THE 'PI' EVALUATION
CALL SYNTAX_Z JR Z,S_PI_END ; forward if checking syntax RST _FP_CALC ;; DEFB __stk_half_pi ;; DEFB __end_calc ;; INC (HL) ; double the exponent giving PI on the stack. mark_0F99: S_PI_END: RST _NEXT_CHAR ; advances character pointer. JP S_NUMERIC ; jump forward to set the flag ; to signal numeric result before advancing. ; ___ mark_0F9D: S_TST_INK: CP ZX_INKEY_STR ; JR NZ,S_ALPHANUM ; forward, if not
; THE 'INKEY$' EVALUATION
CALL KEYBOARD LD B,H ; LD C,L ; LD D,C ; INC D ; CALL NZ,DECODE LD A,D ; ADC A,D ; LD B,D ; LD C,A ; EX DE,HL ; JR S_STRING ; forward ; ___ mark_0FB2: S_ALPHANUM: CALL ALPHANUM JR C,S_LTR_DGT ; forward, if alphanumeric CP ZX_PERIOD ; is character a '.' ? JP Z,S_DECIMAL ; jump forward if so LD BC,$09D8 ; prepare priority 09, operation 'subtract' CP ZX_MINUS ; is character unary minus '-' ? JR Z,S_PUSH_PO ; forward, if so CP ZX_BRACKET_LEFT ; is character a '(' ? JR NZ,S_QUOTE ; forward if not CALL CH_ADD_PLUS_1 ; advances character pointer. CALL SCANNING ; recursively call to evaluate the sub_expression. CP ZX_BRACKET_RIGHT; is subsequent character a ')' ? JR NZ,S_RPT_C ; forward if not CALL CH_ADD_PLUS_1 ; advances. JR S_J_CONT_3 ; relative jump to S_JP_CONT3 and then S_CONT3 ; ___ ; consider a quoted string e.g. PRINT "Hooray!" ; Note. quotes are not allowed within a string. mark_0FD6: S_QUOTE: CP ZX_QUOTE ; is character a quote (") ? JR NZ,S_FUNCTION ; forward, if not CALL CH_ADD_PLUS_1 ; advances PUSH HL ; * save start of string. JR S_QUOTE_S ; forward ; ___ mark_0FE0: S_Q_AGAIN: CALL CH_ADD_PLUS_1 mark_0FE3: S_QUOTE_S: CP ZX_QUOTE ; is character a '"' ? JR NZ,S_Q_NL ; forward if not to S_Q_NL POP DE ; * retrieve start of string AND A ; prepare to subtract. SBC HL,DE ; subtract start from current position. LD B,H ; transfer this length LD C,L ; to the BC register pair. mark_0FED: S_STRING: LD HL,FLAGS ; address system variable FLAGS RES 6,(HL) ; signal string result BIT 7,(HL) ; test if checking syntax. CALL NZ,STK_STO_STR ; in run-time stacks the ; string descriptor - start DE, length BC. RST _NEXT_CHAR ; advances pointer. mark_0FF8: S_J_CONT_3: JP S_CONT_3 ; ___ ; A string with no terminating quote has to be considered. mark_0FFB: S_Q_NL: CP ZX_NEWLINE JR NZ,S_Q_AGAIN ; loop back if not mark_0FFF: S_RPT_C: JP REPORT_C ; ___ mark_1002: S_FUNCTION: SUB $C4 ; subtract 'CODE' reducing codes ; CODE thru '<>' to range $00 - $XX JR C,S_RPT_C ; back, if less ; test for NOT the last function in character set. LD BC,$04EC ; prepare priority $04, operation 'not' CP $13 ; compare to 'NOT' ( - CODE) JR Z,S_PUSH_PO ; forward, if so JR NC,S_RPT_C ; back with anything higher ; else is a function 'CODE' thru 'CHR$' LD B,$10 ; priority sixteen binds all functions to ; arguments removing the need for brackets. ADD A,$D9 ; add $D9 to give range $D9 thru $EB ; bit 6 is set to show numeric argument. ; bit 7 is set to show numeric result. ; now adjust these default argument/result indicators. LD C,A ; save code in C CP $DC ; separate 'CODE', 'VAL', 'LEN' JR NC,S_NUMBER_TO_STRING ; skip forward if string operand RES 6,C ; signal string operand. mark_101A: S_NUMBER_TO_STRING: CP $EA ; isolate top of range 'STR$' and 'CHR$' JR C,S_PUSH_PO ; skip forward with others RES 7,C ; signal string result. mark_1020: S_PUSH_PO: PUSH BC ; push the priority/operation RST _NEXT_CHAR JP S_LOOP_1 ; jump back ; ___ mark_1025: S_LTR_DGT: CP ZX_A ; compare to 'A'. JR C,S_DECIMAL ; forward if less to S_DECIMAL CALL LOOK_VARS JP C,REPORT_2 ; back if not found ; a variable is always 'found' when checking ; syntax. CALL Z,STK_VAR ; stacks string parameters or ; returns cell location if numeric. LD A,(FLAGS) ; fetch FLAGS CP $C0 ; compare to numeric result/numeric operand JR C,S_CONT_2 ; forward if not numeric INC HL ; address numeric contents of variable. LD DE,(STKEND) ; set destination to STKEND CALL MOVE_FP ; stacks the five bytes EX DE,HL ; transfer new free location from DE to HL. LD (STKEND),HL ; update STKEND system variable. JR S_CONT_2 ; forward ; ___ ; The Scanning Decimal routine is invoked when a decimal point or digit is ; found in the expression. ; When checking syntax, then the 'hidden floating point' form is placed ; after the number in the BASIC line. ; In run-time, the digits are skipped and the floating point number is picked ; up. mark_1047: S_DECIMAL: CALL SYNTAX_Z JR NZ,S_STK_DEC ; forward in run-time CALL DEC_TO_FP RST _GET_CHAR ; advances HL past digits LD BC,$0006 ; six locations are required. CALL MAKE_ROOM INC HL ; point to first new location LD (HL),$7E ; insert the number marker 126 decimal. INC HL ; increment EX DE,HL ; transfer destination to DE. LD HL,(STKEND) ; set HL from STKEND which points to the ; first location after the 'last value' LD C,$05 ; five bytes to move. AND A ; clear carry. SBC HL,BC ; subtract five pointing to 'last value'. LD (STKEND),HL ; update STKEND thereby 'deleting the value. LDIR ; copy the five value bytes. EX DE,HL ; basic pointer to HL which may be white-space ; following the number. DEC HL ; now points to last of five bytes. CALL TEMP_PTR1 ; advances the character ; address skipping any white-space. JR S_NUMERIC ; forward ; to signal a numeric result. ; ___ ; In run-time the branch is here when a digit or point is encountered. mark_106F: S_STK_DEC: RST _NEXT_CHAR CP $7E ; compare to 'number marker' JR NZ,S_STK_DEC ; loop back until found ; skipping all the digits. INC HL ; point to first of five hidden bytes. LD DE,(STKEND) ; set destination from STKEND system variable CALL MOVE_FP ; stacks the number. LD (STKEND),DE ; update system variable STKEND. LD (CH_ADD),HL ; update system variable CH_ADD. mark_1083: S_NUMERIC: SET 6,(IY+FLAGS-RAMBASE) ; Signal numeric result mark_1087: S_CONT_2: RST _GET_CHAR mark_1088: S_CONT_3: CP ZX_BRACKET_LEFT ; compare to opening bracket '(' JR NZ,S_OPERTR ; forward if not BIT 6,(IY+FLAGS-RAMBASE) ; Numeric or string result? JR NZ,S_LOOP ; forward if numeric ; else is a string CALL SLICING RST _NEXT_CHAR JR S_CONT_3 ; back ; ___ ; the character is now manipulated to form an equivalent in the table of ; calculator literals. This is quite cumbersome and in the ZX Spectrum a ; simple look-up table was introduced at this point. mark_1098: S_OPERTR: LD BC,$00C3 ; prepare operator 'subtract' as default. ; also set B to zero for later indexing. CP ZX_GREATER_THAN ; is character '>' ? JR C,S_LOOP ; forward if less, as ; we have reached end of meaningful expression SUB ZX_MINUS ; is character '-' ? JR NC,SUBMLTDIV ; forward with - * / and '**' '<>' ADD A,13 ; increase others by thirteen ; $09 '>' thru $0C '+' JR GET_PRIO ; forward ; ___ mark_10A7: SUBMLTDIV: CP $03 ; isolate $00 '-', $01 '*', $02 '/' JR C,GET_PRIO ; forward if so ; else possibly originally $D8 '**' thru $DD '<>' already reduced by $16 SUB $C2 ; giving range $00 to $05 JR C,S_LOOP ; forward if less CP $06 ; test the upper limit for nonsense also JR NC,S_LOOP ; forward if so ADD A,$03 ; increase by 3 to give combined operators of ; $00 '-' ; $01 '*' ; $02 '/' ; $03 '**' ; $04 'OR' ; $05 'AND' ; $06 '<=' ; $07 '>=' ; $08 '<>' ; $09 '>' ; $0A '<' ; $0B '=' ; $0C '+' mark_10B5: GET_PRIO: ADD A,C ; add to default operation 'sub' ($C3) LD C,A ; and place in operator byte - C. LD HL,tbl_pri - $C3 ; theoretical base of the priorities table. ADD HL,BC ; add C ( B is zero) LD B,(HL) ; pick up the priority in B mark_10BC: S_LOOP: POP DE ; restore previous LD A,D ; load A with priority. CP B ; is present priority higher JR C,S_TIGHTER ; forward if so to S_TIGHTER AND A ; are both priorities zero JP Z,GET_CHAR ; exit if zero via GET_CHAR PUSH BC ; stack present values PUSH DE ; stack last values CALL SYNTAX_Z JR Z,S_SYNTEST ; forward is checking syntax LD A,E ; fetch last operation AND $3F ; mask off the indicator bits to give true ; calculator literal. LD B,A ; place in the B register for BERG ; perform the single operation RST _FP_CALC ;; DEFB __fp_calc_2 ;; DEFB __end_calc ;; JR S_RUNTEST ; forward ; ___ mark_10D5: S_SYNTEST: LD A,E ; transfer masked operator to A XOR (IY+FLAGS-RAMBASE) ; XOR with FLAGS like results will reset bit 6 AND $40 ; test bit 6 mark_10DB: S_RPORT_C: JP NZ,REPORT_C ; back if results do not agree. ; ___ ; in run-time impose bit 7 of the operator onto bit 6 of the FLAGS mark_10DE: S_RUNTEST: POP DE ; restore last operation. LD HL,FLAGS ; address system variable FLAGS SET 6,(HL) ; presume a numeric result BIT 7,E ; test expected result in operation JR NZ,S_LOOPEND ; forward if numeric RES 6,(HL) ; reset to signal string result mark_10EA: S_LOOPEND: POP BC ; restore present values JR S_LOOP ; back ; ___ mark_10ED: S_TIGHTER: PUSH DE ; push last values and consider these LD A,C ; get the present operator. BIT 6,(IY+FLAGS-RAMBASE) ; Numeric or string result? JR NZ,S_NEXT ; forward if numeric to S_NEXT AND $3F ; strip indicator bits to give clear literal. ADD A,$08 ; add eight - augmenting numeric to equivalent ; string literals. LD C,A ; place plain literal back in C. CP $10 ; compare to 'AND' JR NZ,S_NOT_AND ; forward if not SET 6,C ; set the numeric operand required for 'AND' JR S_NEXT ; forward to S_NEXT ; ___ mark_1102: S_NOT_AND: JR C,S_RPORT_C ; back if less than 'AND' ; Nonsense if '-', '*' etc. CP __strs_add ; compare to 'strs_add' literal JR Z,S_NEXT ; forward if so signaling string result SET 7,C ; set bit to numeric (Boolean) for others. mark_110A: S_NEXT: PUSH BC ; stack 'present' values RST _NEXT_CHAR JP S_LOOP_1 ; jump back
; THE 'TABLE OF PRIORITIES'
mark_110F: tbl_pri: DEFB 6 ; '-' DEFB 8 ; '*' DEFB 8 ; '/' DEFB 10 ; '**' DEFB 2 ; 'OR' DEFB 3 ; 'AND' DEFB 5 ; '<=' DEFB 5 ; '>=' DEFB 5 ; '<>' DEFB 5 ; '>' DEFB 5 ; '<' DEFB 5 ; '=' DEFB 6 ; '+'
; THE 'LOOK_VARS' SUBROUTINE
mark_111C: LOOK_VARS: SET 6,(IY+FLAGS-RAMBASE) ; Signal numeric result RST _GET_CHAR CALL ALPHA JP NC,REPORT_C ; to REPORT_C PUSH HL ; LD C,A ; RST _NEXT_CHAR PUSH HL ; RES 5,C ; CP $10 ; $10 JR Z,V_RUN_SYN SET 6,C ; CP ZX_DOLLAR ; $0D JR Z,V_STR_VAR ; forward SET 5,C ; mark_1139: V_CHAR: CALL ALPHANUM JR NC,V_RUN_SYN ; forward when not RES 6,C ; RST _NEXT_CHAR JR V_CHAR ; loop back ; ___ mark_1143: V_STR_VAR: RST _NEXT_CHAR RES 6,(IY+FLAGS-RAMBASE) ; Signal string result mark_1148: V_RUN_SYN: LD B,C ; CALL SYNTAX_Z JR NZ,V_RUN ; forward LD A,C ; AND $E0 ; SET 7,A ; LD C,A ; JR V_SYNTAX ; forward ; ___ mark_1156: V_RUN: LD HL,(VARS) ; sv mark_1159: V_EACH: LD A,(HL) ; AND $7F ; JR Z,V_80_BYTE ; CP C ; JR NZ,V_NEXT ; RLA ; ADD A,A ; JP P,V_FOUND_2 JR C,V_FOUND_2 POP DE ; PUSH DE ; PUSH HL ; mark_116B: V_MATCHES: INC HL ; mark_116C: V_SPACES: LD A,(DE) ; INC DE ; AND A ; JR Z,V_SPACES ; back CP (HL) ; JR Z,V_MATCHES ; back OR $80 ; CP (HL) ; JR NZ,V_GET_PTR ; forward LD A,(DE) ; CALL ALPHANUM JR NC,V_FOUND_1 ; forward mark_117F: V_GET_PTR: POP HL ; mark_1180: V_NEXT: PUSH BC ; CALL NEXT_ONE EX DE,HL ; POP BC ; JR V_EACH ; back ; ___ mark_1188: V_80_BYTE: SET 7,B ; mark_118A: V_SYNTAX: POP DE ; RST _GET_CHAR CP $10 ; JR Z,V_PASS ; forward SET 5,B ; JR V_END ; forward ; ___ mark_1194: V_FOUND_1: POP DE ; mark_1195: V_FOUND_2: POP DE ; POP DE ; PUSH HL ; RST _GET_CHAR mark_1199: V_PASS: CALL ALPHANUM JR NC,V_END ; forward if not alphanumeric RST _NEXT_CHAR JR V_PASS ; back ; ___ mark_11A1: V_END: POP HL ; RL B ; BIT 6,B ; RET ;
; THE 'STK_VAR' SUBROUTINE
mark_11A7: STK_VAR: XOR A ; LD B,A ; BIT 7,C ; JR NZ,SV_COUNT ; forward BIT 7,(HL) ; JR NZ,SV_ARRAYS ; forward INC A ; mark_11B2: SV_SIMPLE_STR: INC HL ; LD C,(HL) ; INC HL ; LD B,(HL) ; INC HL ; EX DE,HL ; CALL STK_STO_STR RST _GET_CHAR JP SV_SLICE_QUERY ; jump forward ; ___ mark_11BF: SV_ARRAYS: INC HL ; INC HL ; INC HL ; LD B,(HL) ; BIT 6,C ; JR Z,SV_PTR ; forward DEC B ; JR Z,SV_SIMPLE_STR ; forward EX DE,HL ; RST _GET_CHAR CP $10 ; JR NZ,REPORT_3 ; forward EX DE,HL ; mark_11D1: SV_PTR: EX DE,HL ; JR SV_COUNT ; forward ; ___ mark_11D4: SV_COMMA: PUSH HL ; RST _GET_CHAR POP HL ; CP ZX_COMMA ; $1A == 26 JR Z,SV_LOOP ; forward BIT 7,C ; JR Z,REPORT_3 ; forward BIT 6,C ; JR NZ,SV_CLOSE ; forward CP ZX_BRACKET_RIGHT ; $11 JR NZ,SV_RPT_C ; forward RST _NEXT_CHAR RET ; ; ___ mark_11E9: SV_CLOSE: CP ZX_BRACKET_RIGHT ; $11 JR Z,SV_DIM ; forward CP $DF ; JR NZ,SV_RPT_C ; forward mark_11F1: SV_CH_ADD: RST _GET_CHAR DEC HL ; LD (CH_ADD),HL ; sv JR SV_SLICE ; forward ; ___ mark_11F8: SV_COUNT: LD HL,$0000 ; mark_11FB: SV_LOOP: PUSH HL ; RST _NEXT_CHAR POP HL ; LD A,C ; CP ZX_DOUBLE_QUOTE ; JR NZ,SV_MULT ; forward RST _GET_CHAR CP ZX_BRACKET_RIGHT JR Z,SV_DIM ; forward CP ZX_TO ; JR Z,SV_CH_ADD ; back mark_120C: SV_MULT: PUSH BC ; PUSH HL ; CALL DE_DE_PLUS_ONE EX (SP),HL ; EX DE,HL ; CALL INT_EXP1 JR C,REPORT_3 DEC BC ; CALL GET_HL_TIMES_DE ADD HL,BC ; POP DE ; POP BC ; DJNZ SV_COMMA ; loop back BIT 7,C ; mark_1223: SV_RPT_C: JR NZ,SL_RPT_C PUSH HL ; BIT 6,C ; JR NZ,SV_ELEM_STR LD B,D ; LD C,E ; RST _GET_CHAR CP ZX_BRACKET_RIGHT; is character a ')' ? JR Z,SV_NUMBER ; skip forward mark_1231: REPORT_3: RST _ERROR_1 DEFB $02 ; Error Report: Subscript wrong mark_1233: SV_NUMBER: RST _NEXT_CHAR POP HL ; LD DE,$0005 ; CALL GET_HL_TIMES_DE ADD HL,BC ; RET ; return >> ; ___ mark_123D: SV_ELEM_STR: CALL DE_DE_PLUS_ONE EX (SP),HL ; CALL GET_HL_TIMES_DE POP BC ; ADD HL,BC ; INC HL ; LD B,D ; LD C,E ; EX DE,HL ; CALL STK_ST_0 RST _GET_CHAR CP ZX_BRACKET_RIGHT ; is it ')' ? JR Z,SV_DIM ; forward if so CP ZX_COMMA ; $1A == 26 ; is it ',' ? JR NZ,REPORT_3 ; back if not mark_1256: SV_SLICE: CALL SLICING mark_1259: SV_DIM: RST _NEXT_CHAR mark_125A: SV_SLICE_QUERY: CP $10 ; JR Z,SV_SLICE ; back RES 6,(IY+FLAGS-RAMBASE) ; Signal string result RET ; return.
; THE 'SLICING' SUBROUTINE
; ; mark_1263: SLICING: CALL SYNTAX_Z CALL NZ,STK_FETCH RST _NEXT_CHAR CP ZX_BRACKET_RIGHT; is it ')' ? JR Z,SL_STORE ; forward if so PUSH DE ; XOR A ; PUSH AF ; PUSH BC ; LD DE,$0001 ; RST _GET_CHAR POP HL ; CP ZX_TO ; is it 'TO' ? JR Z,SL_SECOND ; forward if so POP AF ; CALL INT_EXP2 PUSH AF ; LD D,B ; LD E,C ; PUSH HL ; RST _GET_CHAR POP HL ; CP ZX_TO ; is it 'TO' ? JR Z,SL_SECOND ; forward if so CP ZX_BRACKET_RIGHT; $11 mark_128B: SL_RPT_C: JP NZ,REPORT_C LD H,D ; LD L,E ; JR SL_DEFINE ; forward ; ___ mark_1292: SL_SECOND: PUSH HL ; RST _NEXT_CHAR POP HL ; CP ZX_BRACKET_RIGHT; is it ')' ? JR Z,SL_DEFINE ; forward if so POP AF ; CALL INT_EXP2 PUSH AF ; RST _GET_CHAR LD H,B ; LD L,C ; CP ZX_BRACKET_RIGHT; is it ')' ? JR NZ,SL_RPT_C ; back if not mark_12A5: SL_DEFINE: POP AF ; EX (SP),HL ; ADD HL,DE ; DEC HL ; EX (SP),HL ; AND A ; SBC HL,DE ; LD BC,$0000 ; JR C,SL_OVER ; forward INC HL ; AND A ; JP M,REPORT_3 ; jump back LD B,H ; LD C,L ; mark_12B9: SL_OVER: POP DE ; RES 6,(IY+FLAGS-RAMBASE) ; Signal string result mark_12BE: SL_STORE: CALL SYNTAX_Z RET Z ; return if checking syntax.
; THE 'STK_STORE' SUBROUTINE
; ; mark_12C2: STK_ST_0: XOR A ; mark_12C3: STK_STO_STR: PUSH BC ; CALL TEST_5_SP POP BC ; LD HL,(STKEND) ; sv LD (HL),A ; INC HL ; LD (HL),E ; INC HL ; LD (HL),D ; INC HL ; LD (HL),C ; INC HL ; LD (HL),B ; INC HL ; LD (STKEND),HL ; sv RES 6,(IY+FLAGS-RAMBASE) ; Signal string result RET ; return.
; THE 'INT EXP' SUBROUTINES
; ; mark_12DD: INT_EXP1: XOR A ; mark_12DE: INT_EXP2: PUSH DE ; PUSH HL ; PUSH AF ; CALL CLASS_6 POP AF ; CALL SYNTAX_Z JR Z,I_RESTORE ; forward if checking syntax PUSH AF ; CALL FIND_INT POP DE ; LD A,B ; OR C ; SCF ; Set Carry Flag JR Z,I_CARRY ; forward POP HL ; PUSH HL ; AND A ; SBC HL,BC ; mark_12F9: I_CARRY: LD A,D ; SBC A,$00 ; mark_12FC: I_RESTORE: POP HL ; POP DE ; RET ;
; THE 'DE,(DE+1)' SUBROUTINE
; INDEX and LOAD Z80 subroutine. ; This emulates the 6800 processor instruction LDX 1,X which loads a two_byte ; value from memory into the register indexing it. Often these are hardly worth ; the bother of writing as subroutines and this one doesn't save any time or ; memory. The timing and space overheads have to be offset against the ease of ; writing and the greater program readability from using such toolkit routines. mark_12FF: DE_DE_PLUS_ONE: EX DE,HL ; move index address into HL. INC HL ; increment to address word. LD E,(HL) ; pick up word low_order byte. INC HL ; index high_order byte and LD D,(HL) ; pick it up. RET ; return with DE = word.
; THE 'GET_HL_TIMES_DE' SUBROUTINE
; mark_1305: GET_HL_TIMES_DE: CALL SYNTAX_Z RET Z ; PUSH BC ; LD B,$10 ; LD A,H ; LD C,L ; LD HL,$0000 ; mark_1311: HL_LOOP: ADD HL,HL ; JR C,HL_END ; forward with carry RL C ; RLA ; JR NC,HL_AGAIN ; forward with no carry ADD HL,DE ; mark_131A: HL_END: JP C,REPORT_4 mark_131D: HL_AGAIN: DJNZ HL_LOOP ; loop back POP BC ; RET ; return.
; THE 'LET' SUBROUTINE
; ; mark_1321: LET: LD HL,(DEST) BIT 1,(IY+FLAGX-RAMBASE) JR Z,L_EXISTS ; forward LD BC,$0005 ; mark_132D: L_EACH_CH: INC BC ; ; check mark_132E: L_NO_SP: INC HL ; LD A,(HL) ; AND A ; JR Z,L_NO_SP ; back CALL ALPHANUM JR C,L_EACH_CH ; back CP ZX_DOLLAR ; is it '$' ? JP Z,L_NEW_STR ; forward if so RST _BC_SPACES ; BC_SPACES PUSH DE ; LD HL,(DEST) ; DEC DE ; LD A,C ; SUB $06 ; LD B,A ; LD A,$40 ; JR Z,L_SINGLE mark_134B: L_CHAR: INC HL ; LD A,(HL) ; AND A ; is it a space ? JR Z,L_CHAR ; back INC DE ; LD (DE),A ; DJNZ L_CHAR ; loop back OR $80 ; LD (DE),A ; LD A,$80 ; mark_1359: L_SINGLE: LD HL,(DEST) ; XOR (HL) ; POP HL ; CALL L_FIRST mark_1361: L_NUMERIC: PUSH HL ; RST _FP_CALC ;; DEFB __delete ;; DEFB __end_calc ;; POP HL ; LD BC,$0005 ; AND A ; SBC HL,BC ; JR L_ENTER ; forward ; ___ mark_136E: L_EXISTS: BIT 6,(IY+FLAGS-RAMBASE) ; Numeric or string result? JR Z,L_DELETE_STR ; forward LD DE,$0006 ; ADD HL,DE ; JR L_NUMERIC ; back ; ___ mark_137A: L_DELETE_STR: LD HL,(DEST) ; LD BC,(STRLEN) ; BIT 0,(IY+FLAGX-RAMBASE) JR NZ,L_ADD_STR ; forward LD A,B ; OR C ; RET Z ; PUSH HL ; RST _BC_SPACES PUSH DE ; PUSH BC ; LD D,H ; LD E,L ; INC HL ; LD (HL),$00 ; LDDR ; Copy Bytes PUSH HL ; CALL STK_FETCH POP HL ; EX (SP),HL ; AND A ; SBC HL,BC ; ADD HL,BC ; JR NC,L_LENGTH ; forward LD B,H ; LD C,L ; mark_13A3: L_LENGTH: EX (SP),HL ; EX DE,HL ; LD A,B ; OR C ; JR Z,L_IN_W_S ; forward if zero LDIR ; Copy Bytes mark_13AB: L_IN_W_S: POP BC ; POP DE ; POP HL ;
; THE 'L_ENTER' SUBROUTINE ; ; Part of the LET command contains a natural subroutine which is a ; conditional LDIR. The copy only occurs of BC is non-zero.
mark_13AE: L_ENTER: EX DE,HL ; #if ORIGINAL #else COND_MV #endif LD A,B ; OR C ; RET Z ; PUSH DE ; LDIR ; Copy Bytes POP HL ; RET ; return.
mark_13B7: L_ADD_STR: DEC HL ; DEC HL ; DEC HL ; LD A,(HL) ; PUSH HL ; PUSH BC ; CALL L_STRING POP BC ; POP HL ; INC BC ; INC BC ; INC BC ; JP RECLAIM_2 ; jump back to exit via RECLAIM_2 ; ___ mark_13C8: L_NEW_STR: LD A,$60 ; prepare mask %01100000 LD HL,(DEST) ; XOR (HL) ;
; THE 'L_STRING' SUBROUTINE
; mark_13CE: L_STRING: PUSH AF ; CALL STK_FETCH EX DE,HL ; ADD HL,BC ; PUSH HL ; INC BC ; INC BC ; INC BC ; RST _BC_SPACES EX DE,HL ; POP HL ; DEC BC ; DEC BC ; PUSH BC ; LDDR ; Copy Bytes EX DE,HL ; POP BC ; DEC BC ; LD (HL),B ; DEC HL ; LD (HL),C ; POP AF ; mark_13E7: L_FIRST: PUSH AF ; CALL REC_V80 POP AF ; DEC HL ; LD (HL),A ; LD HL,(STKBOT) ; sv LD (E_LINE),HL ; sv DEC HL ; LD (HL),$80 ; RET ;
; THE 'STK_FETCH' SUBROUTINE
; This routine fetches a five-byte value from the calculator stack ; reducing the pointer to the end of the stack by five. ; For a floating-point number the exponent is in A and the mantissa ; is the thirty-two bits EDCB. ; For strings, the start of the string is in DE and the length in BC. ; A is unused. mark_13F8: STK_FETCH: LD HL,(STKEND) ; load HL from system variable STKEND DEC HL ; LD B,(HL) ; DEC HL ; LD C,(HL) ; DEC HL ; LD D,(HL) ; DEC HL ; LD E,(HL) ; DEC HL ; LD A,(HL) ; LD (STKEND),HL ; set system variable STKEND to lower value. RET ; return.
; THE 'DIM' COMMAND ROUTINE
; An array is created and initialized to zeros which is also the space ; character on the ZX81. mark_1409: DIM: CALL LOOK_VARS mark_140C: D_RPORT_C: JP NZ,REPORT_C CALL SYNTAX_Z JR NZ,D_RUN ; forward RES 6,C ; CALL STK_VAR CALL CHECK_END mark_141C: D_RUN: JR C,D_LETTER ; forward PUSH BC ; CALL NEXT_ONE CALL RECLAIM_2 POP BC ; mark_1426: D_LETTER: SET 7,C ; LD B,$00 ; PUSH BC ; LD HL,$0001 ; BIT 6,C ; JR NZ,D_SIZE ; forward LD L,$05 ; mark_1434: D_SIZE: EX DE,HL ; mark_1435: D_NO_LOOP: RST _NEXT_CHAR LD H,$40 ; CALL INT_EXP1 JP C,REPORT_3 POP HL ; PUSH BC ; INC H ; PUSH HL ; LD H,B ; LD L,C ; CALL GET_HL_TIMES_DE EX DE,HL ; RST _GET_CHAR CP ZX_COMMA ; $1A == 26 JR Z,D_NO_LOOP ; back CP ZX_BRACKET_RIGHT; is it ')' ? JR NZ,D_RPORT_C ; back if not RST _NEXT_CHAR POP BC ; LD A,C ; LD L,B ; LD H,$00 ; INC HL ; INC HL ; ADD HL,HL ; ADD HL,DE ; JP C,REPORT_4 PUSH DE ; PUSH BC ; PUSH HL ; LD B,H ; LD C,L ; LD HL,(E_LINE) ; sv DEC HL ; CALL MAKE_ROOM INC HL ; LD (HL),A ; POP BC ; DEC BC ; DEC BC ; DEC BC ; INC HL ; LD (HL),C ; INC HL ; LD (HL),B ; POP AF ; INC HL ; LD (HL),A ; LD H,D ; LD L,E ; DEC DE ; LD (HL),0 ; POP BC ; LDDR ; Copy Bytes mark_147F: DIM_SIZES: POP BC ; LD (HL),B ; DEC HL ; LD (HL),C ; DEC HL ; DEC A ; JR NZ,DIM_SIZES ; back RET ; return.
; THE 'RESERVE' ROUTINE
; ; mark_1488: RESERVE: LD HL,(STKBOT) ; address STKBOT DEC HL ; now last byte of workspace CALL MAKE_ROOM INC HL ; INC HL ; POP BC ; LD (E_LINE),BC ; sv POP BC ; EX DE,HL ; INC HL ; RET ;
; THE 'CLEAR' COMMAND ROUTINE
; ; mark_149A: CLEAR: LD HL,(VARS) ; sv LD (HL),$80 ; INC HL ; LD (E_LINE),HL ; sv
; THE 'X_TEMP' SUBROUTINE
; ; mark_14A3: X_TEMP: LD HL,(E_LINE) ; sv
; THE 'SET_STK' ROUTINES
; ; mark_14A6: SET_STK_B: LD (STKBOT),HL ; sv ; mark_14A9: SET_STK_E: LD (STKEND),HL ; sv RET ;
; THE 'CURSOR_IN' ROUTINE
; This routine is called to set the edit line to the minimum cursor/newline ; and to set STKEND, the start of free space, at the next position. mark_14AD: CURSOR_IN: LD HL,(E_LINE) ; fetch start of edit line LD (HL),ZX_CURSOR ; insert cursor character INC HL ; point to next location. LD (HL),ZX_NEWLINE ; insert NEWLINE character INC HL ; point to next free location. LD (IY+DF_SZ-RAMBASE),2 ; set lower screen display file size JR SET_STK_B ; exit via SET_STK_B above
; THE 'SET_MIN' SUBROUTINE
; ; mark_14BC: SET_MIN: LD HL,$405D ; normal location of calculator's memory area LD (MEM),HL ; update system variable MEM LD HL,(STKBOT) ; JR SET_STK_E ; back
; THE 'RECLAIM THE END_MARKER' ROUTINE
mark_14C7: REC_V80: LD DE,(E_LINE) ; sv JP RECLAIM_1
; THE 'ALPHA' SUBROUTINE
mark_14CE: ALPHA: CP ZX_A ; $26 JR ALPHA_2 ; skip forward
; THE 'ALPHANUM' SUBROUTINE
mark_14D2: ALPHANUM: CP ZX_0 ; mark_14D4: ALPHA_2: CCF ; Complement Carry Flag RET NC ; CP $40 ; RET ;
; THE 'DECIMAL TO FLOATING POINT' SUBROUTINE
; mark_14D9: DEC_TO_FP: CALL INT_TO_FP ; gets first part CP ZX_PERIOD ; is character a '.' ? JR NZ,E_FORMAT ; forward if not RST _FP_CALC ;; DEFB __stk_one ;; DEFB __st_mem_0 ;; DEFB __delete ;; DEFB __end_calc ;; mark_14E5: NXT_DGT_1: RST _NEXT_CHAR CALL STK_DIGIT JR C,E_FORMAT ; forward RST _FP_CALC ;; DEFB __get_mem_0 ;; DEFB __stk_ten ;; #if ORIGINAL DEFB __division ; DEFB $C0 ;;st-mem-0 DEFB __multiply ;; #else DEFB $04 ;;+multiply DEFB $C0 ;;st-mem-0 DEFB $05 ;;+division #endif DEFB __addition ;; DEFB __end_calc ;; JR NXT_DGT_1 ; loop back till exhausted ; ___ mark_14F5: E_FORMAT: CP ZX_E ; is character 'E' ? RET NZ ; return if not LD (IY+MEM_0_1st-RAMBASE),$FF ; initialize sv MEM_0_1st to $FF TRUE RST _NEXT_CHAR CP ZX_PLUS ; is character a '+' ? JR Z,SIGN_DONE ; forward if so CP ZX_MINUS ; is it a '-' ? JR NZ,ST_E_PART ; forward if not INC (IY+MEM_0_1st-RAMBASE) ; sv MEM_0_1st change to FALSE mark_1508: SIGN_DONE: RST _NEXT_CHAR mark_1509: ST_E_PART: CALL INT_TO_FP RST _FP_CALC ;; m, e. DEFB __get_mem_0 ;; m, e, (1/0) TRUE/FALSE DEFB __jump_true ;; DEFB E_POSTVE - $ ;; DEFB __negate ;; m, _e mark_1511: E_POSTVE: DEFB __e_to_fp ;; x. DEFB __end_calc ;; x. RET ; return.
; THE 'STK_DIGIT' SUBROUTINE
; mark_1514: STK_DIGIT: CP ZX_0 ; RET C ; CP ZX_A ; $26 CCF ; Complement Carry Flag RET C ; SUB ZX_0 ;
; THE 'STACK_A' SUBROUTINE
; mark_151D: STACK_A: LD C,A ; LD B,0 ;
; THE 'STACK_BC' SUBROUTINE
; The ZX81 does not have an integer number format so the BC register contents ; must be converted to their full floating-point form. mark_1520: STACK_BC: LD IY,ERR_NR ; re-initialize the system variables pointer. PUSH BC ; save the integer value. ; now stack zero, five zero bytes as a starting point. RST _FP_CALC ;; DEFB __stk_zero ;; 0. DEFB __end_calc ;; POP BC ; restore integer value. LD (HL),$91 ; place $91 in exponent 65536. ; this is the maximum possible value LD A,B ; fetch hi-byte. AND A ; test for zero. JR NZ,STK_BC_2 ; forward if not zero LD (HL),A ; else make exponent zero again OR C ; test lo-byte RET Z ; return if BC was zero - done. ; else there has to be a set bit if only the value one. LD B,C ; save C in B. LD C,(HL) ; fetch zero to C LD (HL),$89 ; make exponent $89 256. mark_1536: STK_BC_2: DEC (HL) ; decrement exponent - halving number SLA C ; C<-76543210<-0 RL B ; C<-76543210<-C JR NC,STK_BC_2 ; loop back if no carry SRL B ; 0->76543210->C RR C ; C->76543210->C INC HL ; address first byte of mantissa LD (HL),B ; insert B INC HL ; address second byte of mantissa LD (HL),C ; insert C DEC HL ; point to the DEC HL ; exponent again RET ; return.
; THE 'INTEGER TO FLOATING POINT' SUBROUTINE
; ; mark_1548: INT_TO_FP: PUSH AF ; RST _FP_CALC ;; DEFB __stk_zero ;; DEFB __end_calc ;; POP AF ; mark_154D: NXT_DGT_2: CALL STK_DIGIT RET C ; RST _FP_CALC ;; DEFB __exchange ;; DEFB __stk_ten ;; DEFB __multiply ;; DEFB __addition ;; DEFB __end_calc ;; RST _NEXT_CHAR JR NXT_DGT_2
; THE 'E_FORMAT TO FLOATING POINT' SUBROUTINE
; (Offset $38: 'e_to_fp') ; invoked from DEC_TO_FP and PRINT_FP. ; e.g. 2.3E4 is 23000. ; This subroutine evaluates xEm where m is a positive or negative integer. ; At a simple level x is multiplied by ten for every unit of m. ; If the decimal exponent m is negative then x is divided by ten for each unit. ; A short-cut is taken if the exponent is greater than seven and in this ; case the exponent is reduced by seven and the value is multiplied or divided ; by ten million. ; Note. for the ZX Spectrum an even cleverer method was adopted which involved ; shifting the bits out of the exponent so the result was achieved with six ; shifts at most. The routine below had to be completely re-written mostly ; in Z80 machine code. ; Although no longer operable, the calculator literal was retained for old ; times sake, the routine being invoked directly from a machine code CALL. ; ; On entry in the ZX81, m, the exponent, is the 'last value', and the ; floating-point decimal mantissa is beneath it. mark_155A: e_to_fp: RST _FP_CALC ;; x, m. DEFB __duplicate ;; x, m, m. DEFB __less_0 ;; x, m, (1/0). DEFB __st_mem_0 ;; x, m, (1/0). DEFB __delete ;; x, m. DEFB __abs ;; x, +m. mark_1560: E_LOOP: DEFB __stk_one ;; x, m,1. DEFB __subtract ;; x, m-1. DEFB __duplicate ;; x, m-1,m-1. DEFB __less_0 ;; x, m-1, (1/0). DEFB __jump_true ;; x, m-1. DEFB E_END - $ ;; x, m-1. DEFB __duplicate ;; x, m-1, m-1. DEFB __stk_data ;; DEFB $33 ;;Exponent: $83, Bytes: 1 DEFB $40 ;;(+00,+00,+00) x, m-1, m-1, 6. DEFB __subtract ;; x, m-1, m-7. DEFB __duplicate ;; x, m-1, m-7, m-7. DEFB __less_0 ;; x, m-1, m-7, (1/0). DEFB __jump_true ;; x, m-1, m-7. DEFB E_LOW - $ ;; ; but if exponent m is higher than 7 do a bigger chunk. ; multiplying (or dividing if negative) by 10 million - 1e7. DEFB __exchange ;; x, m-7, m-1. DEFB __delete ;; x, m-7. DEFB __exchange ;; m-7, x. DEFB __stk_data ;; DEFB $80 ;;Bytes: 3 DEFB $48 ;;Exponent $98 DEFB $18,$96,$80 ;;(+00) m-7, x, 10,000,000 (=f) DEFB __jump ;; DEFB E_CHUNK - $ ;; ; ___ mark_157A: E_LOW: DEFB __delete ;; x, m-1. DEFB __exchange ;; m-1, x. DEFB __stk_ten ;; m-1, x, 10 (=f). mark_157D: E_CHUNK: DEFB __get_mem_0 ;; m-1, x, f, (1/0) DEFB __jump_true ;; m-1, x, f DEFB E_DIVSN - $ ;; DEFB __multiply ;; m-1, x*f. DEFB __jump ;; DEFB E_SWAP - $ ;; ; ___ mark_1583: E_DIVSN: DEFB __division ;; m-1, x/f (= new x). mark_1584: E_SWAP: DEFB __exchange ;; x, m-1 (= new m). DEFB __jump ;; x, m. DEFB E_LOOP - $ ;; ; ___ mark_1587: E_END: DEFB __delete ;; x. (-1) DEFB __end_calc ;; x. RET ; return.
; THE 'FLOATING-POINT TO BC' SUBROUTINE
; The floating-point form on the calculator stack is compressed directly into ; the BC register rounding up if necessary. ; Valid range is 0 to 65535.4999 mark_158A: FP_TO_BC: CALL STK_FETCH ; exponent to A ; mantissa to EDCB. AND A ; test for value zero. JR NZ,FPBC_NZRO ; forward if not ; else value is zero LD B,A ; zero to B LD C,A ; also to C PUSH AF ; save the flags on machine stack JR FPBC_END ; forward ; ___ ; EDCB => BCE mark_1595: FPBC_NZRO: LD B,E ; transfer the mantissa from EDCB LD E,C ; to BCE. Bit 7 of E is the 17th bit which LD C,D ; will be significant for rounding if the ; number is already normalized. SUB $91 ; subtract 65536 CCF ; complement carry flag BIT 7,B ; test sign bit PUSH AF ; push the result SET 7,B ; set the implied bit JR C,FPBC_END ; forward with carry from SUB/CCF ; number is too big. INC A ; increment the exponent and NEG ; negate to make range $00 - $0F CP $08 ; test if one or two bytes JR C,BIG_INT ; forward with two LD E,C ; shift mantissa LD C,B ; 8 places right LD B,$00 ; insert a zero in B SUB $08 ; reduce exponent by eight mark_15AF: BIG_INT: AND A ; test the exponent LD D,A ; save exponent in D. LD A,E ; fractional bits to A RLCA ; rotate most significant bit to carry for ; rounding of an already normal number. JR Z,EXP_ZERO ; forward if exponent zero ; the number is normalized mark_15B5: FPBC_NORM: SRL B ; 0->76543210->C RR C ; C->76543210->C DEC D ; decrement exponent JR NZ,FPBC_NORM ; loop back till zero mark_15BC: EXP_ZERO: JR NC,FPBC_END ; forward without carry to NO_ROUND ??? INC BC ; round up. LD A,B ; test result OR C ; for zero JR NZ,FPBC_END ; forward if not to GRE_ZERO ??? POP AF ; restore sign flag SCF ; set carry flag to indicate overflow PUSH AF ; save combined flags again mark_15C6: FPBC_END: PUSH BC ; save BC value ; set HL and DE to calculator stack pointers. RST _FP_CALC ;; DEFB __end_calc ;; POP BC ; restore BC value POP AF ; restore flags LD A,C ; copy low byte to A also. RET ; return
; THE 'FLOATING-POINT TO A' SUBROUTINE
; ; mark_15CD: FP_TO_A: CALL FP_TO_BC RET C ; PUSH AF ; DEC B ; INC B ; JR Z,FP_A_END ; forward if in range POP AF ; fetch result SCF ; set carry flag signaling overflow RET ; return mark_15D9: FP_A_END: POP AF ; RET ;
; THE 'PRINT A FLOATING-POINT NUMBER' SUBROUTINE
; prints 'last value' x on calculator stack. ; There are a wide variety of formats see Chapter 4. ; e.g. ; PI prints as 3.1415927 ; .123 prints as 0.123 ; .0123 prints as .0123 ; 999999999999 prints as 1000000000000 ; 9876543210123 prints as 9876543200000 ; Begin by isolating zero and just printing the '0' character ; for that case. For negative numbers print a leading '-' and ; then form the absolute value of x. mark_15DB: PRINT_FP: RST _FP_CALC ;; x. DEFB __duplicate ;; x, x. DEFB __less_0 ;; x, (1/0). DEFB __jump_true ;; DEFB PF_NEGTVE - $ ;; x. DEFB __duplicate ;; x, x DEFB __greater_0 ;; x, (1/0). DEFB __jump_true ;; DEFB PF_POSTVE - $ ;; x. DEFB __delete ;; . DEFB __end_calc ;; . LD A,ZX_0 ; load accumulator with character '0' RST _PRINT_A RET ; return. >> ; ___ mark_15EA: PF_NEGTVE: DEFB __abs ;; +x. DEFB __end_calc ;; x. LD A,ZX_MINUS ; load accumulator with '-' RST _PRINT_A RST _FP_CALC ;; x. mark_15F0: PF_POSTVE: DEFB __end_calc ;; x. ; register HL addresses the exponent of the floating-point value. ; if positive, and point floats to left, then bit 7 is set. LD A,(HL) ; pick up the exponent byte CALL STACK_A ; places on calculator stack. ; now calculate roughly the number of digits, n, before the decimal point by ; subtracting a half from true exponent and multiplying by log to ; the base 10 of 2. ; The true number could be one higher than n, the integer result. RST _FP_CALC ;; x, e. DEFB __stk_data ;; DEFB $78 ;;Exponent: $88, Bytes: 2 DEFB $00,$80 ;;(+00,+00) x, e, 128.5. DEFB __subtract ;; x, e -.5. DEFB __stk_data ;; DEFB $EF ;;Exponent: $7F, Bytes: 4 DEFB $1A,$20,$9A,$85 ;; .30103 (log10 2) DEFB __multiply ;; x, DEFB __int ;; DEFB __st_mem_1 ;; x, n. DEFB __stk_data ;; DEFB $34 ;;Exponent: $84, Bytes: 1 DEFB $00 ;;(+00,+00,+00) x, n, 8. DEFB __subtract ;; x, n-8. DEFB __negate ;; x, 8-n. DEFB __e_to_fp ;; x * (10^n) ; finally the 8 or 9 digit decimal is rounded. ; a ten-digit integer can arise in the case of, say, 999999999.5 ; which gives 1000000000. DEFB __stk_half ;; DEFB __addition ;; DEFB __int ;; i. DEFB __end_calc ;; ; If there were 8 digits then final rounding will take place on the calculator ; stack above and the next two instructions insert a masked zero so that ; no further rounding occurs. If the result is a 9 digit integer then ; rounding takes place within the buffer. LD HL,$406B ; address system variable MEM_2_5th ; which could be the 'ninth' digit. LD (HL),$90 ; insert the value $90 10010000 ; now starting from lowest digit lay down the 8, 9 or 10 digit integer ; which represents the significant portion of the number ; e.g. PI will be the nine-digit integer 314159265 LD B,10 ; count is ten digits. mark_1615: PF_LOOP: INC HL ; increase pointer PUSH HL ; preserve buffer address. PUSH BC ; preserve counter. RST _FP_CALC ;; i. DEFB __stk_ten ;; i, 10. DEFB __n_mod_m ;; i mod 10, i/10 DEFB __exchange ;; i/10, remainder. DEFB __end_calc ;; CALL FP_TO_A ; $00-$09 OR $90 ; make left hand nibble 9 POP BC ; restore counter POP HL ; restore buffer address. LD (HL),A ; insert masked digit in buffer. DJNZ PF_LOOP ; loop back for all ten ; the most significant digit will be last but if the number is exhausted then ; the last one or two positions will contain zero ($90). ; e.g. for 'one' we have zero as estimate of leading digits. ; 1*10^8 100000000 as integer value ; 90 90 90 90 90 90 90 90 91 90 as buffer mem3/mem4 contents. INC HL ; advance pointer to one past buffer LD BC,$0008 ; set C to 8 ( B is already zero ) PUSH HL ; save pointer. mark_162C: PF_NULL: DEC HL ; decrease pointer LD A,(HL) ; fetch masked digit CP $90 ; is it a leading zero ? JR Z,PF_NULL ; loop back if so ; at this point a significant digit has been found. carry is reset. SBC HL,BC ; subtract eight from the address. PUSH HL ; ** save this pointer too LD A,(HL) ; fetch addressed byte ADD A,$6B ; add $6B - forcing a round up ripple ; if $95 or over. PUSH AF ; save the carry result. ; now enter a loop to round the number. After rounding has been considered ; a zero that has arisen from rounding or that was present at that position ; originally is changed from $90 to $80. mark_1639: PF_RND_LP: POP AF ; retrieve carry from machine stack. INC HL ; increment address LD A,(HL) ; fetch new byte ADC A,0 ; add in any carry DAA ; decimal adjust accumulator ; carry will ripple through the '9' PUSH AF ; save carry on machine stack. AND $0F ; isolate character 0 - 9 AND set zero flag ; if zero. LD (HL),A ; place back in location. SET 7,(HL) ; set bit 7 to show printable. ; but not if trailing zero after decimal point. JR Z,PF_RND_LP ; back if a zero ; to consider further rounding and/or trailing ; zero identification. POP AF ; balance stack POP HL ; ** retrieve lower pointer ; now insert 6 trailing zeros which are printed if before the decimal point ; but mark the end of printing if after decimal point. ; e.g. 9876543210123 is printed as 9876543200000 ; 123.456001 is printed as 123.456 LD B,6 ; the count is six. mark_164B: PF_ZERO_6: LD (HL),$80 ; insert a masked zero DEC HL ; decrease pointer. DJNZ PF_ZERO_6 ; loop back for all six ; n-mod-m reduced the number to zero and this is now deleted from the calculator ; stack before fetching the original estimate of leading digits. RST _FP_CALC ;; 0. DEFB __delete ;; . DEFB __get_mem_1 ;; n. DEFB __end_calc ;; n. CALL FP_TO_A JR Z,PF_POS ; skip forward if positive NEG ; negate makes positive mark_165B: PF_POS: LD E,A ; transfer count of digits to E INC E ; increment twice INC E ; POP HL ; * retrieve pointer to one past buffer. mark_165F: GET_FIRST: DEC HL ; decrement address. DEC E ; decrement digit counter. LD A,(HL) ; fetch masked byte. AND $0F ; isolate right-hand nibble. JR Z,GET_FIRST ; back with leading zero ; now determine if E-format printing is needed LD A,E ; transfer now accurate number count to A. SUB 5 ; subtract five CP 8 ; compare with 8 as maximum digits is 13. JP P,PF_E_FMT ; forward if positive to PF_E_FMT CP $F6 ; test for more than four zeros after point. JP M,PF_E_FMT ; forward if so to PF_E_FMT ADD A,6 ; test for zero leading digits, e.g. 0.5 JR Z,PF_ZERO_1 ; forward if so to PF_ZERO_1 JP M,PF_ZEROS ; forward if more than one zero to PF_ZEROS ; else digits before the decimal point are to be printed LD B,A ; count of leading characters to B. mark_167B: PF_NIB_LP: CALL PF_NIBBLE DJNZ PF_NIB_LP ; loop back for counted numbers JR PF_DC_OUT ; forward to consider decimal part to PF_DC_OUT ; ___ mark_1682: PF_E_FMT: LD B,E ; count to B CALL PF_NIBBLE ; prints one digit. CALL PF_DC_OUT ; considers fractional part. LD A,ZX_E ; RST _PRINT_A LD A,B ; transfer exponent to A AND A ; test the sign. JP P,PF_E_POS ; forward if positive to PF_E_POS NEG ; negate the negative exponent. LD B,A ; save positive exponent in B. LD A,ZX_MINUS ; JR PF_E_SIGN ; skip forward to PF_E_SIGN ; ___ mark_1698: PF_E_POS: LD A,ZX_PLUS ; mark_169A: PF_E_SIGN: RST _PRINT_A ; now convert the integer exponent in B to two characters. ; it will be less than 99. LD A,B ; fetch positive exponent. LD B,$FF ; initialize left hand digit to minus one. mark_169E: PF_E_TENS: INC B ; increment ten count SUB 10 ; subtract ten from exponent JR NC,PF_E_TENS ; loop back if greater than ten ADD A,10 ; reverse last subtraction LD C,A ; transfer remainder to C LD A,B ; transfer ten value to A. AND A ; test for zero. JR Z,PF_E_LOW ; skip forward if so to PF_E_LOW CALL OUT_CODE ; prints as digit '1' - '9' mark_16AD: PF_E_LOW: LD A,C ; low byte to A CALL OUT_CODE ; prints final digit of the ; exponent. RET ; return. >>
; THE 'FLOATING POINT PRINT ZEROS' LOOP ; ------------------------------------- ; This branch deals with zeros after decimal point. ; e.g. .01 or .0000999 ; Note. that printing to the ZX Printer destroys A and that A should be ; initialized to '0' at each stage of the loop. ; Originally LPRINT .00001 printed as .0XYZ1
mark_16B2: PF_ZEROS: NEG ; negate makes number positive 1 to 4. LD B,A ; zero count to B. LD A,ZX_PERIOD ; prepare character '.' RST _PRINT_A #if ORIGINAL LD A,ZX_0 ; prepare a '0' PFZROLP RST _PRINT_A DJNZ PFZROLP ; obsolete loop back to PFZROLP #else PF_ZRO_LP LD A,ZX_0 ; prepare a '0' in the accumulator each time. RST _PRINT_A DJNZ PF_ZRO_LP ;+ New loop back to PF-ZRO-LP #endif JR PF_FRAC_LP ; forward ; there is a need to print a leading zero e.g. 0.1 but not with .01 mark_16BF: PF_ZERO_1: LD A,ZX_0 ; prepare character '0'. RST _PRINT_A ; this subroutine considers the decimal point and any trailing digits. ; if the next character is a marked zero, $80, then nothing more to print. mark_16C2: PF_DC_OUT: DEC (HL) ; decrement addressed character INC (HL) ; increment it again RET PE ; return with overflow (was 128) >> ; as no fractional part ; else there is a fractional part so print the decimal point. LD A,ZX_PERIOD ; prepare character '.' RST _PRINT_A ; now enter a loop to print trailing digits mark_16C8: PF_FRAC_LP: DEC (HL) ; test for a marked zero. INC (HL) ; RET PE ; return when digits exhausted >> CALL PF_NIBBLE JR PF_FRAC_LP ; back for all fractional digits ; ___ ; subroutine to print right-hand nibble mark_16D0: PF_NIBBLE: LD A,(HL) ; fetch addressed byte AND $0F ; mask off lower 4 bits CALL OUT_CODE DEC HL ; decrement pointer. RET ; return.
; THE 'PREPARE TO ADD' SUBROUTINE
; This routine is called twice to prepare each floating point number for ; addition, in situ, on the calculator stack. ; The exponent is picked up from the first byte which is then cleared to act ; as a sign byte and accept any overflow. ; If the exponent is zero then the number is zero and an early return is made. ; The now redundant sign bit of the mantissa is set and if the number is ; negative then all five bytes of the number are twos-complemented to prepare ; the number for addition. ; On the second invocation the exponent of the first number is in B. mark_16D8: PREP_ADD: LD A,(HL) ; fetch exponent. LD (HL),0 ; make this byte zero to take any overflow and ; default to positive. AND A ; test stored exponent for zero. RET Z ; return with zero flag set if number is zero. INC HL ; point to first byte of mantissa. BIT 7,(HL) ; test the sign bit. SET 7,(HL) ; set it to its implied state. DEC HL ; set pointer to first byte again. RET Z ; return if bit indicated number is positive.>> ; if negative then all five bytes are twos complemented starting at LSB. PUSH BC ; save B register contents. LD BC,$0005 ; set BC to five. ADD HL,BC ; point to location after 5th byte. LD B,C ; set the B counter to five. LD C,A ; store original exponent in C. SCF ; set carry flag so that one is added. ; now enter a loop to twos_complement the number. ; The first of the five bytes becomes $FF to denote a negative number. mark_16EC: NEG_BYTE: DEC HL ; point to first or more significant byte. LD A,(HL) ; fetch to accumulator. CPL ; complement. ADC A,0 ; add in initial carry or any subsequent carry. LD (HL),A ; place number back. DJNZ NEG_BYTE ; loop back five times LD A,C ; restore the exponent to accumulator. POP BC ; restore B register contents. RET ; return.
; THE 'FETCH TWO NUMBERS' SUBROUTINE
; This routine is used by addition, multiplication and division to fetch ; the two five_byte numbers addressed by HL and DE from the calculator stack ; into the Z80 registers. ; The HL register may no longer point to the first of the two numbers. ; Since the 32-bit addition operation is accomplished using two Z80 16-bit ; instructions, it is important that the lower two bytes of each mantissa are ; in one set of registers and the other bytes all in the alternate set. ; ; In: HL = highest number, DE= lowest number ; ; : alt': ; : ; Out: ; :H,B-C:C,B: num1 ; :L,D-E:D-E: num2 mark_16F7: FETCH_TWO: PUSH HL ; save HL PUSH AF ; save A - result sign when used from division. LD C,(HL) ; INC HL ; LD B,(HL) ; LD (HL),A ; insert sign when used from multiplication. INC HL ; LD A,C ; m1 LD C,(HL) ; PUSH BC ; PUSH m2 m3 INC HL ; LD C,(HL) ; m4 INC HL ; LD B,(HL) ; m5 BC holds m5 m4 EX DE,HL ; make HL point to start of second number. LD D,A ; m1 LD E,(HL) ; PUSH DE ; PUSH m1 n1 INC HL ; LD D,(HL) ; INC HL ; LD E,(HL) ; PUSH DE ; PUSH n2 n3 EXX ; - - - - - - - POP DE ; POP n2 n3 POP HL ; POP m1 n1 POP BC ; POP m2 m3 EXX ; - - - - - - - INC HL ; LD D,(HL) ; INC HL ; LD E,(HL) ; DE holds n4 n5 POP AF ; restore saved POP HL ; registers. RET ; return.
; THE 'SHIFT ADDEND' SUBROUTINE
; The accumulator A contains the difference between the two exponents. ; This is the lowest of the two numbers to be added mark_171A: SHIFT_FP: AND A ; test difference between exponents. RET Z ; return if zero. both normal. CP 33 ; compare with 33 bits. JR NC,ADDEND_0 ; forward if greater than 32 PUSH BC ; preserve BC - part LD B,A ; shift counter to B. ; Now perform B right shifts on the addend L'D'E'D E ; to bring it into line with the augend H'B'C'C B mark_1722: ONE_SHIFT: EXX ; - - - SRA L ; 76543210->C bit 7 unchanged. RR D ; C->76543210->C RR E ; C->76543210->C EXX ; - - - RR D ; C->76543210->C RR E ; C->76543210->C DJNZ ONE_SHIFT ; loop back B times POP BC ; restore BC RET NC ; return if last shift produced no carry. >> ; if carry flag was set then accuracy is being lost so round up the addend. CALL ADD_BACK RET NZ ; return if not FF 00 00 00 00 ; this branch makes all five bytes of the addend zero and is made during ; addition when the exponents are too far apart for the addend bits to ; affect the result. mark_1736: ADDEND_0: EXX ; select alternate set for more significant ; bytes. XOR A ; clear accumulator. ; this entry point (from multiplication) sets four of the bytes to zero or if ; continuing from above, during addition, then all five bytes are set to zero. mark_1738: ZEROS_4_OR_5: LD L,0 ; set byte 1 to zero. LD D,A ; set byte 2 to A. LD E,L ; set byte 3 to zero. EXX ; select main set LD DE,$0000 ; set lower bytes 4 and 5 to zero. RET ; return.
; THE 'ADD_BACK' SUBROUTINE
; Called from SHIFT_FP above during addition and after normalization from ; multiplication. ; This is really a 32_bit increment routine which sets the zero flag according ; to the 32-bit result. ; During addition, only negative numbers like FF FF FF FF FF, ; the twos-complement version of xx 80 00 00 01 say ; will result in a full ripple FF 00 00 00 00. ; FF FF FF FF FF when shifted right is unchanged by SHIFT_FP but sets the ; carry invoking this routine. mark_1741: ADD_BACK: INC E ; RET NZ ; INC D ; RET NZ ; EXX ; INC E ; JR NZ,ALL_ADDED ; forward if no overflow INC D ; mark_174A: ALL_ADDED: EXX ; RET ; return with zero flag set for zero mantissa.
; THE 'SUBTRACTION' OPERATION
; just switch the sign of subtrahend and do an add. mark_174C: SUBTRACT: LD A,(DE) ; fetch exponent byte of second number the ; subtrahend. AND A ; test for zero RET Z ; return if zero - first number is result. INC DE ; address the first mantissa byte. LD A,(DE) ; fetch to accumulator. XOR $80 ; toggle the sign bit. LD (DE),A ; place back on calculator stack. DEC DE ; point to exponent byte. ; continue into addition routine.
; THE 'ADDITION' OPERATION
; The addition operation pulls out all the stops and uses most of the Z80's ; registers to add two floating-point numbers. ; This is a binary operation and on entry, HL points to the first number ; and DE to the second. mark_1755: ADDITION: EXX ; - - - PUSH HL ; save the pointer to the next literal. EXX ; - - - PUSH DE ; save pointer to second number PUSH HL ; save pointer to first number - will be the ; result pointer on calculator stack. CALL PREP_ADD LD B,A ; save first exponent byte in B. EX DE,HL ; switch number pointers. CALL PREP_ADD LD C,A ; save second exponent byte in C. CP B ; compare the exponent bytes. JR NC,SHIFT_LEN ; forward if second higher LD A,B ; else higher exponent to A LD B,C ; lower exponent to B EX DE,HL ; switch the number pointers. mark_1769: SHIFT_LEN: PUSH AF ; save higher exponent SUB B ; subtract lower exponent CALL FETCH_TWO CALL SHIFT_FP POP AF ; restore higher exponent. POP HL ; restore result pointer. LD (HL),A ; insert exponent byte. PUSH HL ; save result pointer again. ; now perform the 32-bit addition using two 16-bit Z80 add instructions. LD L,B ; transfer low bytes of mantissa individually LD H,C ; to HL register ADD HL,DE ; the actual binary addition of lower bytes ; now the two higher byte pairs that are in the alternate register sets. EXX ; switch in set EX DE,HL ; transfer high mantissa bytes to HL register. ADC HL,BC ; the actual addition of higher bytes with ; any carry from first stage. EX DE,HL ; result in DE, sign bytes ($FF or $00) to HL ; now consider the two sign bytes LD A,H ; fetch sign byte of num1 ADC A,L ; add including any carry from mantissa ; addition. 00 or 01 or FE or FF LD L,A ; result in L. ; possible outcomes of signs and overflow from mantissa are ; ; H + L + carry = L RRA XOR L RRA
; 00 + 00 = 00 00 00 ; 00 + 00 + carry = 01 00 01 carry ; FF + FF = FE C FF 01 carry ; FF + FF + carry = FF C FF 00 ; FF + 00 = FF FF 00 ; FF + 00 + carry = 00 C 80 80 RRA ; C->76543210->C XOR L ; set bit 0 if shifting required. EXX ; switch back to main set EX DE,HL ; full mantissa result now in D'E'D E registers. POP HL ; restore pointer to result exponent on ; the calculator stack. RRA ; has overflow occurred ? JR NC,TEST_NEG ; skip forward if not ; if the addition of two positive mantissas produced overflow or if the ; addition of two negative mantissas did not then the result exponent has to ; be incremented and the mantissa shifted one place to the right. LD A,1 ; one shift required. CALL SHIFT_FP ; performs a single shift ; rounding any lost bit INC (HL) ; increment the exponent. JR Z,ADD_REP_6 ; forward to ADD_REP_6 if the exponent ; wraps round from FF to zero as number is too ; big for the system. ; at this stage the exponent on the calculator stack is correct. mark_1790: TEST_NEG: EXX ; switch in the alternate set. LD A,L ; load result sign to accumulator. AND $80 ; isolate bit 7 from sign byte setting zero ; flag if positive. EXX ; back to main set. INC HL ; point to first byte of mantissa LD (HL),A ; insert $00 positive or $80 negative at ; position on calculator stack. DEC HL ; point to exponent again. JR Z,GO_NC_MLT ; forward if positive to GO_NC_MLT ; a negative number has to be twos-complemented before being placed on stack. LD A,E ; fetch lowest (rightmost) mantissa byte. NEG ; Negate CCF ; Complement Carry Flag LD E,A ; place back in register LD A,D ; ditto CPL ; ADC A,0 ; LD D,A ; EXX ; switch to higher (leftmost) 16 bits. LD A,E ; ditto CPL ; ADC A,0 ; LD E,A ; LD A,D ; ditto CPL ; ADC A,0 ; JR NC,END_COMPL ; forward without overflow to END_COMPL ; else entire mantissa is now zero. 00 00 00 00 RRA ; set mantissa to 80 00 00 00 EXX ; switch. INC (HL) ; increment the exponent. mark_17B3: ADD_REP_6: JP Z,REPORT_6 ; jump forward if exponent now zero to REPORT_6 ; 'Number too big' EXX ; switch back to alternate set. mark_17B7: END_COMPL: LD D,A ; put first byte of mantissa back in DE. EXX ; switch to main set. mark_17B9: GO_NC_MLT: XOR A ; clear carry flag and ; clear accumulator so no extra bits carried ; forward as occurs in multiplication. JR TEST_NORM ; forward to common code at TEST_NORM ; but should go straight to NORMALIZE.
; THE 'PREPARE TO MULTIPLY OR DIVIDE' SUBROUTINE
; this routine is called twice from multiplication and twice from division ; to prepare each of the two numbers for the operation. ; Initially the accumulator holds zero and after the second invocation bit 7 ; of the accumulator will be the sign bit of the result. mark_17BC: PREP_MULTIPLY_OR_DIVIDE: SCF ; set carry flag to signal number is zero. DEC (HL) ; test exponent INC (HL) ; for zero. RET Z ; return if zero with carry flag set. INC HL ; address first mantissa byte. XOR (HL) ; exclusive or the running sign bit. SET 7,(HL) ; set the implied bit. DEC HL ; point to exponent byte. RET ; return.
; THE 'MULTIPLICATION' OPERATION
; ; mark_17C6: MULTIPLY: XOR A ; reset bit 7 of running sign flag. CALL PREP_MULTIPLY_OR_DIVIDE RET C ; return if number is zero. ; zero * anything = zero. EXX ; - - - PUSH HL ; save pointer to 'next literal' EXX ; - - - PUSH DE ; save pointer to second number EX DE,HL ; make HL address second number. CALL PREP_MULTIPLY_OR_DIVIDE EX DE,HL ; HL first number, DE - second number JR C,ZERO_RESULT ; forward with carry to ZERO_RESULT ; anything * zero = zero. PUSH HL ; save pointer to first number. CALL FETCH_TWO ; fetches two mantissas from ; calc stack to B'C'C,B D'E'D E ; (HL will be overwritten but the result sign ; in A is inserted on the calculator stack) LD A,B ; transfer low mantissa byte of first number AND A ; clear carry. SBC HL,HL ; a short form of LD HL,$0000 to take lower ; two bytes of result. (2 program bytes) EXX ; switch in alternate set PUSH HL ; preserve HL SBC HL,HL ; set HL to zero also to take higher two bytes ; of the result and clear carry. EXX ; switch back. LD B,33 ; register B can now be used to count 33 shifts. JR STRT_MLT ; forward to loop entry point STRT_MLT ; ___ ; The multiplication loop is entered at STRT_LOOP. mark_17E7: MLT_LOOP: JR NC,NO_ADD ; forward if no carry ; else add in the multiplicand. ADD HL,DE ; add the two low bytes to result EXX ; switch to more significant bytes. ADC HL,DE ; add high bytes of multiplicand and any carry. EXX ; switch to main set. ; in either case shift result right into B'C'C A mark_17EE: NO_ADD: EXX ; switch to alternate set RR H ; C > 76543210 > C RR L ; C > 76543210 > C EXX ; RR H ; C > 76543210 > C RR L ; C > 76543210 > C mark_17F8: STRT_MLT: EXX ; switch in alternate set. RR B ; C > 76543210 > C RR C ; C > 76543210 > C EXX ; now main set RR C ; C > 76543210 > C RRA ; C > 76543210 > C DJNZ MLT_LOOP ; loop back 33 timeS ; EX DE,HL ; EXX ; EX DE,HL ; EXX ; POP BC ; POP HL ; LD A,B ; ADD A,C ; JR NZ,MAKE_EXPT ; forward AND A ; mark_180E: MAKE_EXPT: DEC A ; CCF ; Complement Carry Flag mark_1810: DIVN_EXPT: RLA ; CCF ; Complement Carry Flag RRA ; JP P,OFLW1_CLR JR NC,REPORT_6 AND A ; mark_1819: OFLW1_CLR: INC A ; JR NZ,OFLW2_CLR JR C,OFLW2_CLR EXX ; BIT 7,D ; EXX ; JR NZ,REPORT_6 mark_1824: OFLW2_CLR: LD (HL),A ; EXX ; LD A,B ; EXX ; ; addition joins here with carry flag clear. mark_1828: TEST_NORM: JR NC,NORMALIZE ; forward LD A,(HL) ; AND A ; mark_182C: NEAR_ZERO: LD A,$80 ; prepare to rescue the most significant bit ; of the mantissa if it is set. JR Z,SKIP_ZERO ; skip forward mark_1830: ZERO_RESULT: XOR A ; make mask byte zero signaling set five ; bytes to zero. mark_1831: SKIP_ZERO: EXX ; switch in alternate set AND D ; isolate most significant bit (if A is $80). CALL ZEROS_4_OR_5 ; sets mantissa without ; affecting any flags. RLCA ; test if MSB set. bit 7 goes to bit 0. ; either $00 -> $00 or $80 -> $01 LD (HL),A ; make exponent $01 (lowest) or $00 zero JR C,OFLOW_CLR ; forward if first case INC HL ; address first mantissa byte on the ; calculator stack. LD (HL),A ; insert a zero for the sign bit. DEC HL ; point to zero exponent JR OFLOW_CLR ; forward ; ___ ; this branch is common to addition and multiplication with the mantissa ; result still in registers D'E'D E . mark_183F: NORMALIZE: LD B,32 ; a maximum of thirty-two left shifts will be ; needed. mark_1841: SHIFT_ONE: EXX ; address higher 16 bits. BIT 7,D ; test the leftmost bit EXX ; address lower 16 bits. JR NZ,NORML_NOW ; forward if leftmost bit was set RLCA ; this holds zero from addition, 33rd bit ; from multiplication. RL E ; C < 76543210 < C RL D ; C < 76543210 < C EXX ; address higher 16 bits. RL E ; C < 76543210 < C RL D ; C < 76543210 < C EXX ; switch to main set. DEC (HL) ; decrement the exponent byte on the calculator ; stack. JR Z,NEAR_ZERO ; back if exponent becomes zero ; it's just possible that the last rotation ; set bit 7 of D. We shall see. DJNZ SHIFT_ONE ; loop back ; if thirty-two left shifts were performed without setting the most significant ; bit then the result is zero. JR ZERO_RESULT ; back ; ___ mark_1859: NORML_NOW: RLA ; for the addition path, A is always zero. ; for the mult path, ... JR NC,OFLOW_CLR ; forward ; this branch is taken only with multiplication. CALL ADD_BACK JR NZ,OFLOW_CLR ; forward EXX ; LD D,$80 ; EXX ; INC (HL) ; JR Z,REPORT_6 ; forward ; now transfer the mantissa from the register sets to the calculator stack ; incorporating the sign bit already there. mark_1868: OFLOW_CLR: PUSH HL ; save pointer to exponent on stack. INC HL ; address first byte of mantissa which was ; previously loaded with sign bit $00 or $80. EXX ; - - - PUSH DE ; push the most significant two bytes. EXX ; - - - POP BC ; pop - true mantissa is now BCDE. ; now pick up the sign bit. LD A,B ; first mantissa byte to A RLA ; rotate out bit 7 which is set RL (HL) ; rotate sign bit on stack into carry. RRA ; rotate sign bit into bit 7 of mantissa. ; and transfer mantissa from main registers to calculator stack. LD (HL),A ; INC HL ; LD (HL),C ; INC HL ; LD (HL),D ; INC HL ; LD (HL),E ; POP HL ; restore pointer to num1 now result. POP DE ; restore pointer to num2 now STKEND. EXX ; - - - POP HL ; restore pointer to next calculator literal. EXX ; - - - RET ; return. ; ___ mark_1880: REPORT_6: RST _ERROR_1 DEFB 5 ; Error Report: Arithmetic overflow.
; THE 'DIVISION' OPERATION
; "Of all the arithmetic subroutines, division is the most complicated and ; the least understood. It is particularly interesting to note that the ; Sinclair programmer himself has made a mistake in his programming ( or has ; copied over someone else's mistake!) for ; PRINT PEEK 6352 [ $18D0 ] ('unimproved' ROM, 6351 [ $18CF ] ) ; should give 218 not 225." ; - Dr. Ian Logan, Syntax magazine Jul/Aug 1982. ; [ i.e. the jump should be made to div-34th ] ; First check for division by zero. mark_1882: DIVISION: EX DE,HL ; consider the second number first. XOR A ; set the running sign flag. CALL PREP_MULTIPLY_OR_DIVIDE JR C,REPORT_6 ; back if zero ; 'Arithmetic overflow' EX DE,HL ; now prepare first number and check for zero. CALL PREP_MULTIPLY_OR_DIVIDE RET C ; return if zero, 0/anything is zero. EXX ; - - - PUSH HL ; save pointer to the next calculator literal. EXX ; - - - PUSH DE ; save pointer to divisor - will be STKEND. PUSH HL ; save pointer to dividend - will be result. CALL FETCH_TWO ; fetches the two numbers ; into the registers H'B'C'C B ; L'D'E'D E EXX ; - - - PUSH HL ; save the two exponents. LD H,B ; transfer the dividend to H'L'H L LD L,C ; EXX ; LD H,C ; LD L,B ; XOR A ; clear carry bit and accumulator. LD B,$DF ; count upwards from -33 decimal JR DIVISION_START ; forward to mid-loop entry point ; ___ mark_18A2: DIV_LOOP: RLA ; multiply partial quotient by two RL C ; setting result bit from carry. EXX ; RL C ; RL B ; EXX ; mark_18AB: DIV_34TH: ADD HL,HL ; EXX ; ADC HL,HL ; EXX ; JR C,SUBN_ONLY ; forward mark_18B2: DIVISION_START: SBC HL,DE ; subtract divisor part. EXX ; SBC HL,DE ; EXX ; JR NC,NUM_RESTORE ; forward if subtraction goes ADD HL,DE ; else restore EXX ; ADC HL,DE ; EXX ; AND A ; clear carry JR COUNT_ONE ; forward ; ___ mark_18C2: SUBN_ONLY: AND A ; SBC HL,DE ; EXX ; SBC HL,DE ; EXX ; mark_18C9: NUM_RESTORE: SCF ; set carry flag mark_18CA: COUNT_ONE: INC B ; increment the counter JP M,DIV_LOOP ; back while still minus to DIV_LOOP PUSH AF ; JR Z,DIVISION_START ; back to DIV_START ; "This jump is made to the wrong place. No 34th bit will ever be obtained ; without first shifting the dividend. Hence important results like 1/10 and ; 1/1000 are not rounded up as they should be. Rounding up never occurs when ; it depends on the 34th bit. The jump should be made to div_34th above." ; - Dr. Frank O'Hara, "The Complete Spectrum ROM Disassembly", 1983, ; published by Melbourne House. ; (Note. on the ZX81 this would be JR Z,DIV_34TH) ; ; However if you make this change, then while (1/2=.5) will now evaluate as ; true, (.25=1/4), which did evaluate as true, no longer does. LD E,A ; LD D,C ; EXX ; LD E,C ; LD D,B ; POP AF ; RR B ; POP AF ; RR B ; EXX ; POP BC ; POP HL ; LD A,B ; SUB C ; JP DIVN_EXPT ; jump back
; THE 'INTEGER TRUNCATION TOWARDS ZERO' SUBROUTINE
; mark_18E4: TRUNCATE: LD A,(HL) ; fetch exponent CP $81 ; compare to +1 JR NC,T_GR_ZERO ; forward, if 1 or more ; else the number is smaller than plus or minus 1 and can be made zero. LD (HL),$00 ; make exponent zero. LD A,$20 ; prepare to set 32 bits of mantissa to zero. JR NIL_BYTES ; forward ; ___ mark_18EF: T_GR_ZERO: SUB $A0 ; subtract +32 from exponent RET P ; return if result is positive as all 32 bits ; of the mantissa relate to the integer part. ; The floating point is somewhere to the right ; of the mantissa NEG ; else negate to form number of rightmost bits ; to be blanked. ; for instance, disregarding the sign bit, the number 3.5 is held as ; exponent $82 mantissa .11100000 00000000 00000000 00000000 ; we need to set $82 - $A0 = $E2 NEG = $1E (thirty) bits to zero to form the ; integer. ; The sign of the number is never considered as the first bit of the mantissa ; must be part of the integer. mark_18F4: NIL_BYTES: PUSH DE ; save pointer to STKEND EX DE,HL ; HL points at STKEND DEC HL ; now at last byte of mantissa. LD B,A ; Transfer bit count to B register. SRL B ; divide by SRL B ; eight SRL B ; JR Z,BITS_ZERO ; forward if zero ; else the original count was eight or more and whole bytes can be blanked. mark_1900: BYTE_ZERO: LD (HL),0 ; set eight bits to zero. DEC HL ; point to more significant byte of mantissa. DJNZ BYTE_ZERO ; loop back ; now consider any residual bits. mark_1905: BITS_ZERO: AND $07 ; isolate the remaining bits JR Z,IX_END ; forward if none LD B,A ; transfer bit count to B counter. LD A,$FF ; form a mask 11111111 mark_190C: LESS_MASK: SLA A ; 1 <- 76543210 <- o slide mask leftwards. DJNZ LESS_MASK ; loop back for bit count AND (HL) ; lose the unwanted rightmost bits LD (HL),A ; and place in mantissa byte. mark_1912: IX_END: EX DE,HL ; restore result pointer from DE. POP DE ; restore STKEND from stack. RET ; return.
; Up to this point all routine addresses have been maintained so that the ; modified ROM is compatible with any machine-code software that uses ROM ; routines. ; The final section does not maintain address entry points as the routines ; within are not generally called directly.
;** FLOATING-POINT CALCULATOR ** ;******************************** ; As a general rule the calculator avoids using the IY register. ; Exceptions are val and str$. ; So an assembly language programmer who has disabled interrupts to use IY ; for other purposes can still use the calculator for mathematical ; purposes.
; THE 'TABLE OF CONSTANTS'
; The ZX81 has only floating-point number representation. ; Both the ZX80 and the ZX Spectrum have integer numbers in some form. TAB_CNST #if ORIGINAL mark_1915: ; 00 00 00 00 00 stk_zero: DEFB $00 ;;Bytes: 1 DEFB $B0 ;;Exponent $00 DEFB $00 ;;(+00,+00,+00) mark_1918: ; 81 00 00 00 00 stk_one: DEFB $31 ;;Exponent $81, Bytes: 1 DEFB $00 ;;(+00,+00,+00) mark_191A: ; 80 00 00 00 00 stk_half: DEFB $30 ;;Exponent: $80, Bytes: 1 DEFB $00 ;;(+00,+00,+00) mark_191C: ; 81 49 0F DA A2 stk_half_pi: DEFB $F1 ;;Exponent: $81, Bytes: 4 DEFB $49,$0F,$DA,$A2 ;; mark_1921: ; 84 20 00 00 00 stk_ten: DEFB $34 ;;Exponent: $84, Bytes: 1 DEFB $20 ;;(+00,+00,+00) #else ; This table has been modified so that the constants are held in their ; uncompressed, ready-to-use, 5-byte form. DEFB $00 ; the value zero. DEFB $00 ; DEFB $00 ; DEFB $00 ; DEFB $00 ; DEFB $81 ; the floating point value 1. DEFB $00 ; DEFB $00 ; DEFB $00 ; DEFB $00 ; DEFB $80 ; the floating point value 1/2. DEFB $00 ; DEFB $00 ; DEFB $00 ; DEFB $00 ; DEFB $81 ; the floating point value pi/2. DEFB $49 ; DEFB $0F ; DEFB $DA ; DEFB $A2 ; DEFB $84 ; the floating point value ten. DEFB $20 ; DEFB $00 ; DEFB $00 ; DEFB $00 ; #endif
; THE 'TABLE OF ADDRESSES'
; ; starts with binary operations which have two operands and one result. ; three pseudo binary operations first. #if ORIGINAL mark_1923: #else #endif tbl_addrs: DEFW jump_true ; $00 Address: $1C2F - jump_true DEFW exchange ; $01 Address: $1A72 - exchange DEFW delete ; $02 Address: $19E3 - delete ; true binary operations. DEFW SUBTRACT ; $03 Address: $174C - subtract DEFW MULTIPLY ; $04 Address: $176C - multiply DEFW DIVISION ; $05 Address: $1882 - division DEFW to_power ; $06 Address: $1DE2 - to_power DEFW or ; $07 Address: $1AED - or DEFW boolean_num_and_num ; $08 Address: $1AF3 - boolean_num_and_num DEFW num_l_eql ; $09 Address: $1B03 - num_l_eql DEFW num_gr_eql ; $0A Address: $1B03 - num_gr_eql DEFW nums_neql ; $0B Address: $1B03 - nums_neql DEFW num_grtr ; $0C Address: $1B03 - num_grtr DEFW num_less ; $0D Address: $1B03 - num_less DEFW nums_eql ; $0E Address: $1B03 - nums_eql DEFW ADDITION ; $0F Address: $1755 - addition DEFW strs_and_num ; $10 Address: $1AF8 - str_and_num DEFW str_l_eql ; $11 Address: $1B03 - str_l_eql DEFW str_gr_eql ; $12 Address: $1B03 - str_gr_eql DEFW strs_neql ; $13 Address: $1B03 - strs_neql DEFW str_grtr ; $14 Address: $1B03 - str_grtr DEFW str_less ; $15 Address: $1B03 - str_less DEFW strs_eql ; $16 Address: $1B03 - strs_eql DEFW strs_add ; $17 Address: $1B62 - strs_add ; unary follow DEFW neg ; $18 DEFW code ; $19 DEFW val ; $1A DEFW len ; $1B DEFW sin ; $1C DEFW cos ; $1D DEFW tan ; $1E DEFW asn ; $1F DEFW acs ; $20 DEFW atn ; $21 DEFW ln ; $22 DEFW exp ; $23 DEFW int ; $24 DEFW sqr ; $25 DEFW sgn ; $26 DEFW abs ; $27 DEFW PEEK ; $28 Address: $1A1B - peek !!!! DEFW usr_num ; $29 DEFW str_dollar ; $2A DEFW chr_dollar ; $2B DEFW not ; $2C ; end of true unary DEFW duplicate ; $2D DEFW n_mod_m ; $2E DEFW jump ; $2F DEFW stk_data ; $30 DEFW dec_jr_nz ; $31 DEFW less_0 ; $32 DEFW greater_0 ; $33 DEFW end_calc ; $34 DEFW get_argt ; $35 DEFW TRUNCATE ; $36 DEFW FP_CALC_2 ; $37 DEFW e_to_fp ; $38 ; the following are just the next available slots for the 128 compound literals ; which are in range $80 - $FF. DEFW series_xx ; $39 : $80 - $9F. DEFW stk_const_xx ; $3A : $A0 - $BF. DEFW st_mem_xx ; $3B : $C0 - $DF. DEFW get_mem_xx ; $3C : $E0 - $FF. ; Aside: 3D - 7F are therefore unused calculator literals. ; 39 - 7B would be available for expansion.
; THE 'FLOATING POINT CALCULATOR'
; ; mark_199D: CALCULATE: CALL STACK_POINTERS ; is called to set up the ; calculator stack pointers for a default ; unary operation. HL = last value on stack. ; DE = STKEND first location after stack. ; the calculate routine is called at this point by the series generator... mark_19A0: GEN_ENT_1: LD A,B ; fetch the Z80 B register to A LD (BERG),A ; and store value in system variable BERG. ; this will be the counter for dec_jr_nz ; or if used from FP_CALC2 the calculator ; instruction. ; ... and again later at this point mark_19A4: GEN_ENT_2: EXX ; switch sets EX (SP),HL ; and store the address of next instruction, ; the return address, in H'L'. ; If this is a recursive call then the H'L' ; of the previous invocation goes on stack. ; c.f. end_calc. EXX ; switch back to main set. ; this is the re-entry looping point when handling a string of literals. mark_19A7: RE_ENTRY: LD (STKEND),DE ; save end of stack EXX ; switch to alt LD A,(HL) ; get next literal INC HL ; increase pointer' ; single operation jumps back to here mark_19AE: SCAN_ENT: PUSH HL ; save pointer on stack * AND A ; now test the literal JP P,FIRST_3D ; forward if in range $00 - $3D ; anything with bit 7 set will be one of ; 128 compound literals. ; compound literals have the following format. ; bit 7 set indicates compound. ; bits 6-5 the subgroup 0-3. ; bits 4-0 the embedded parameter $00 - $1F. ; The subgroup 0-3 needs to be manipulated to form the next available four ; address places after the simple literals in the address table. LD D,A ; save literal in D AND $60 ; and with 01100000 to isolate subgroup RRCA ; rotate bits RRCA ; 4 places to right RRCA ; not five as we need offset * 2 RRCA ; 00000xx0 ADD A,$72 ; add ($39 * 2) to give correct offset. ; alter above if you add more literals. LD L,A ; store in L for later indexing. LD A,D ; bring back compound literal AND $1F ; use mask to isolate parameter bits JR ENT_TABLE ; forward ; ___ ; the branch was here with simple literals. mark_19C2: FIRST_3D: CP $18 ; compare with first unary operations. JR NC,DOUBLE_A ; with unary operations ; it is binary so adjust pointers. EXX ; LD BC,-5 LD D,H ; transfer HL, the last value, to DE. LD E,L ; ADD HL,BC ; subtract 5 making HL point to second ; value. EXX ; mark_19CE: DOUBLE_A: RLCA ; double the literal LD L,A ; and store in L for indexing mark_19D0: ENT_TABLE: LD DE,tbl_addrs ; Address: tbl_addrs LD H,$00 ; prepare to index ADD HL,DE ; add to get address of routine LD E,(HL) ; low byte to E INC HL ; LD D,(HL) ; high byte to D LD HL,RE_ENTRY EX (SP),HL ; goes on machine stack ; address of next literal goes to HL. * PUSH DE ; now the address of routine is stacked. EXX ; back to main set ; avoid using IY register. LD BC,(STKEND+1) ; STKEND_hi ; nothing much goes to C but BERG to B ; and continue into next ret instruction ; which has a dual identity
; THE 'DELETE' SUBROUTINE
; offset $02: 'delete' ; A simple return but when used as a calculator literal this ; deletes the last value from the calculator stack. ; On entry, as always with binary operations, ; HL=first number, DE=second number ; On exit, HL=result, DE=stkend. ; So nothing to do mark_19E3: delete: RET ; return - indirect jump if from above.
; THE 'SINGLE OPERATION' SUBROUTINE
; offset $37: 'FP_CALC_2' ; this single operation is used, in the first instance, to evaluate most ; of the mathematical and string functions found in BASIC expressions. mark_19E4: FP_CALC_2: POP AF ; drop return address. LD A,(BERG) ; load accumulator from system variable BERG ; value will be literal eg. 'tan' EXX ; switch to alt JR SCAN_ENT ; back ; next literal will be end_calc in scanning
; THE 'TEST 5 SPACES' SUBROUTINE
; This routine is called from MOVE_FP, STK_CONST and STK_STORE to ; test that there is enough space between the calculator stack and the ; machine stack for another five_byte value. It returns with BC holding ; the value 5 ready for any subsequent LDIR. mark_19EB: TEST_5_SP: PUSH DE ; save PUSH HL ; registers LD BC,5 ; an overhead of five bytes CALL TEST_ROOM ; tests free RAM raising ; an error if not. POP HL ; else restore POP DE ; registers. RET ; return with BC set at 5.
; THE 'MOVE A FLOATING POINT NUMBER' SUBROUTINE
; offset $2D: 'duplicate' ; This simple routine is a 5-byte LDIR instruction ; that incorporates a memory check. ; When used as a calculator literal it duplicates the last value on the ; calculator stack. ; Unary so on entry HL points to last value, DE to stkend mark_19F6: duplicate: MOVE_FP: CALL TEST_5_SP ; test free memory ; and sets BC to 5. LDIR ; copy the five bytes. RET ; return with DE addressing new STKEND ; and HL addressing new last value.
; THE 'STACK LITERALS' SUBROUTINE
; offset $30: 'stk_data' ; When a calculator subroutine needs to put a value on the calculator ; stack that is not a regular constant this routine is called with a ; variable number of following data bytes that convey to the routine ; the floating point form as succinctly as is possible. mark_19FC: stk_data: LD H,D ; transfer STKEND LD L,E ; to HL for result. mark_19FE: STK_CONST: CALL TEST_5_SP ; tests that room exists ; and sets BC to $05. EXX ; switch to alternate set PUSH HL ; save the pointer to next literal on stack EXX ; switch back to main set EX (SP),HL ; pointer to HL, destination to stack. #if ORIGINAL PUSH BC ; save BC - value 5 from test room ??. #else ;; PUSH BC ; save BC - value 5 from test room. No need. #endif LD A,(HL) ; fetch the byte following 'stk_data' AND $C0 ; isolate bits 7 and 6 RLCA ; rotate RLCA ; to bits 1 and 0 range $00 - $03. LD C,A ; transfer to C INC C ; and increment to give number of bytes ; to read. $01 - $04 LD A,(HL) ; reload the first byte AND $3F ; mask off to give possible exponent. JR NZ,FORM_EXP ; forward to FORM_EXP if it was possible to ; include the exponent. ; else byte is just a byte count and exponent comes next. INC HL ; address next byte and LD A,(HL) ; pick up the exponent ( - $50). mark_1A14: FORM_EXP: ADD A,$50 ; now add $50 to form actual exponent LD (DE),A ; and load into first destination byte. LD A,$05 ; load accumulator with $05 and SUB C ; subtract C to give count of trailing ; zeros plus one. INC HL ; increment source INC DE ; increment destination #if ORIGINAL LD B,$00 ; prepare to copy. Note. B is zero. LDIR ; copy C bytes POP BC ; restore 5 counter to BC. #else LDIR ; copy C bytes #endif EX (SP),HL ; put HL on stack as next literal pointer ; and the stack value - result pointer - ; to HL. EXX ; switch to alternate set. POP HL ; restore next literal pointer from stack ; to H'L'. EXX ; switch back to main set. LD B,A ; zero count to B XOR A ; clear accumulator mark_1A27: STK_ZEROS: DEC B ; decrement B counter RET Z ; return if zero. >> ; DE points to new STKEND ; HL to new number. LD (DE),A ; else load zero to destination INC DE ; increase destination JR STK_ZEROS ; loop back until done.
; THE 'SKIP CONSTANTS' SUBROUTINE
; This routine traverses variable-length entries in the table of constants, ; stacking intermediate, unwanted constants onto a dummy calculator stack, ; in the first five bytes of the ZX81 ROM. #if ORIGINAL mark_1A2D: SKIP_CONS: AND A ; test if initially zero. mark_1A2E: SKIP_NEXT: RET Z ; return if zero. >> PUSH AF ; save count. PUSH DE ; and normal STKEND LD DE,$0000 ; dummy value for STKEND at start of ROM ; Note. not a fault but this has to be ; moved elsewhere when running in RAM. ; CALL STK_CONST ; works through variable ; length records. POP DE ; restore real STKEND POP AF ; restore count DEC A ; decrease JR SKIP_NEXT ; loop back #else ; Since the table now uses uncompressed values, some extra ROM space is ; required for the table but much more is released by getting rid of routines ; like this. #endif
; THE 'MEMORY LOCATION' SUBROUTINE
; This routine, when supplied with a base address in HL and an index in A, ; will calculate the address of the A'th entry, where each entry occupies ; five bytes. It is used for addressing floating-point numbers in the ; calculator's memory area. mark_1A3C: LOC_MEM: LD C,A ; store the original number $00-$1F. RLCA ; double. RLCA ; quadruple. ADD A,C ; now add original value to multiply by five. LD C,A ; place the result in C. LD B,$00 ; set B to 0. ADD HL,BC ; add to form address of start of number in HL. RET ; return.
; THE 'GET FROM MEMORY AREA' SUBROUTINE
; offsets $E0 to $FF: 'get_mem_0', 'get_mem_1' etc. ; A holds $00-$1F offset. ; The calculator stack increases by 5 bytes. mark_1A45: get_mem_xx: #if ORIGINAL PUSH DE ; save STKEND LD HL,(MEM) ; MEM is base address of the memory cells. #else ; Note. first two instructions have been swapped to create a subroutine. LD HL,(MEM) ; MEM is base address of the memory cells. INDEX_5 ; new label PUSH DE ; save STKEND #endif CALL LOC_MEM ; so that HL = first byte CALL MOVE_FP ; moves 5 bytes with memory ; check. ; DE now points to new STKEND. POP HL ; the original STKEND is now RESULT pointer. RET ; return.
; THE 'STACK A CONSTANT' SUBROUTINE
stk_const_xx: #if ORIGINAL ; offset $A0: 'stk_zero' ; offset $A1: 'stk_one' ; offset $A2: 'stk_half' ; offset $A3: 'stk_half_pi' ; offset $A4: 'stk_ten' ; ; This routine allows a one-byte instruction to stack up to 32 constants ; held in short form in a table of constants. In fact only 5 constants are ; required. On entry the A register holds the literal ANDed with $1F. ; It isn't very efficient and it would have been better to hold the ; numbers in full, five byte form and stack them in a similar manner ; to that which would be used later for semi-tone table values. mark_1A51: LD H,D ; save STKEND - required for result LD L,E ; EXX ; swap PUSH HL ; save pointer to next literal LD HL,stk_zero ; Address: stk_zero - start of table of ; constants EXX ; CALL SKIP_CONS CALL STK_CONST EXX ; POP HL ; restore pointer to next literal. EXX ; RET ; return. #else stk_con_x LD HL,TAB_CNST ; Address: Table of constants. JR INDEX_5 ; and join subroutine above. #endif
; THE 'STORE IN A MEMORY AREA' SUBROUTINE
; Offsets $C0 to $DF: 'st_mem_0', 'st_mem_1' etc. ; Although 32 memory storage locations can be addressed, only six ; $C0 to $C5 are required by the ROM and only the thirty bytes (6*5) ; required for these are allocated. ZX81 programmers who wish to ; use the floating point routines from assembly language may wish to ; alter the system variable MEM to point to 160 bytes of RAM to have ; use the full range available. ; A holds derived offset $00-$1F. ; Unary so on entry HL points to last value, DE to STKEND. mark_1A63: st_mem_xx: PUSH HL ; save the result pointer. EX DE,HL ; transfer to DE. LD HL,(MEM) ; fetch MEM the base of memory area. CALL LOC_MEM ; sets HL to the destination. EX DE,HL ; swap - HL is start, DE is destination. #if ORIGINAL CALL MOVE_FP ; note. a short ld bc,5; ldir ; the embedded memory check is not required ; so these instructions would be faster! #else LD C,5 ;+ one extra byte but LDIR ;+ faster and no memory check. #endif EX DE,HL ; DE = STKEND POP HL ; restore original result pointer RET ; return.
; THE 'EXCHANGE' SUBROUTINE
; offset $01: 'exchange' ; This routine exchanges the last two values on the calculator stack ; On entry, as always with binary operations, ; HL=first number, DE=second number ; On exit, HL=result, DE=stkend. mark_1A72: exchange: LD B,$05 ; there are five bytes to be swapped ; start of loop. mark_1A74: SWAP_BYTE: LD A,(DE) ; each byte of second #if ORIGINAL LD C,(HL) ; each byte of first EX DE,HL ; swap pointers #else LD C,A ;+ LD A,(HL) #endif LD (DE),A ; store each byte of first LD (HL),C ; store each byte of second INC HL ; advance both INC DE ; pointers. DJNZ SWAP_BYTE ; loop back until all 5 done. #if ORIGINAL EX DE,HL ; even up the exchanges so that DE addresses STKEND. #else ; omit #endif RET ; return.
; THE 'SERIES GENERATOR' SUBROUTINE
; The ZX81 uses Chebyshev polynomials to generate approximations for ; SIN, ATN, LN and EXP. These are named after the Russian mathematician ; Pafnuty Chebyshev, born in 1821, who did much pioneering work on numerical ; series. As far as calculators are concerned, Chebyshev polynomials have an ; advantage over other series, for example the Taylor series, as they can ; reach an approximation in just six iterations for SIN, eight for EXP and ; twelve for LN and ATN. The mechanics of the routine are interesting but ; for full treatment of how these are generated with demonstrations in ; Sinclair BASIC see "The Complete Spectrum ROM Disassembly" by Dr Ian Logan ; and Dr Frank O'Hara, published 1983 by Melbourne House. mark_1A7F: series_xx: LD B,A ; parameter $00 - $1F to B counter CALL GEN_ENT_1 ; A recursive call to a special entry point ; in the calculator that puts the B register ; in the system variable BERG. The return ; address is the next location and where ; the calculator will expect its first ; instruction - now pointed to by HL'. ; The previous pointer to the series of ; five-byte numbers goes on the machine stack. ; The initialization phase. DEFB __duplicate ;; x,x DEFB __addition ;; x+x DEFB __st_mem_0 ;; x+x DEFB __delete ;; . DEFB __stk_zero ;; 0 DEFB __st_mem_2 ;; 0 ; a loop is now entered to perform the algebraic calculation for each of ; the numbers in the series mark_1A89: G_LOOP: DEFB __duplicate ;; v,v. DEFB __get_mem_0 ;; v,v,x+2 DEFB __multiply ;; v,v*x+2 DEFB __get_mem_2 ;; v,v*x+2,v DEFB __st_mem_1 ;; DEFB __subtract ;; DEFB __end_calc ;; ; the previous pointer is fetched from the machine stack to H'L' where it ; addresses one of the numbers of the series following the series literal. CALL stk_data ; is called directly to ; push a value and advance H'L'. CALL GEN_ENT_2 ; recursively re-enters ; the calculator without disturbing ; system variable BERG ; H'L' value goes on the machine stack and is ; then loaded as usual with the next address. DEFB __addition ;; DEFB __exchange ;; DEFB __st_mem_2 ;; DEFB __delete ;; DEFB __dec_jr_nz ;; DEFB $EE ;;back to G_LOOP, G_LOOP ; when the counted loop is complete the final subtraction yields the result ; for example SIN X. DEFB __get_mem_1 ;; DEFB __subtract ;; DEFB __end_calc ;; RET ; return with H'L' pointing to location ; after last number in series.
; Handle unary minus (18)
; Unary so on entry HL points to last value, DE to STKEND. mark_1AA0: mark_1AA0: neg: LD A, (HL) ; fetch exponent of last value on the ; calculator stack. AND A ; test it. RET Z ; return if zero. INC HL ; address the byte with the sign bit. LD A,(HL) ; fetch to accumulator. XOR $80 ; toggle the sign bit. LD (HL),A ; put it back. DEC HL ; point to last value again. RET ; return.
; Absolute magnitude (27)
; This calculator literal finds the absolute value of the last value, ; floating point, on calculator stack. mark_1AAA: abs: INC HL ; point to byte with sign bit. RES 7,(HL) ; make the sign positive. DEC HL ; point to last value again. RET ; return.
; Signum (26)
; This routine replaces the last value on the calculator stack, ; which is in floating point form, with one if positive and with -minus one ; if negative. If it is zero then it is left as such. mark_1AAF: sgn: INC HL ; point to first byte of 4-byte mantissa. LD A,(HL) ; pick up the byte with the sign bit. DEC HL ; point to exponent. DEC (HL) ; test the exponent for INC (HL) ; the value zero. SCF ; set the carry flag. CALL NZ,FP_0_OR_1 ; replaces last value with one ; if exponent indicates the value is non-zero. ; in either case mantissa is now four zeros. INC HL ; point to first byte of 4-byte mantissa. RLCA ; rotate original sign bit to carry. RR (HL) ; rotate the carry into sign. DEC HL ; point to last value. RET ; return.
; Handle PEEK function (28)
; This function returns the contents of a memory address. ; The entire address space can be peeked including the ROM. mark_1ABE: PEEK: CALL FIND_INT ; puts address in BC. LD A,(BC) ; load contents into A register. mark_1AC2: IN_PK_STK: JP STACK_A ; exit via STACK_A to put value on the ; calculator stack.
; USR number (29)
; The USR function followed by a number 0-65535 is the method by which ; the ZX81 invokes machine code programs. This function returns the ; contents of the BC register pair. ; Note. that STACK_BC re-initializes the IY register to ERR_NR if a user-written ; program has altered it. mark_1AC5: usr_num: CALL FIND_INT ; to fetch the ; supplied address into BC. LD HL,STACK_BC ; address: STACK_BC is PUSH HL ; pushed onto the machine stack. PUSH BC ; then the address of the machine code ; routine. RET ; make an indirect jump to the routine ; and, hopefully, to STACK_BC also.
; Greater than zero ($33)
; Test if the last value on the calculator stack is greater than zero. ; This routine is also called directly from the end-tests of the comparison ; routine. mark_1ACE: greater_0: LD A,(HL) ; fetch exponent. AND A ; test it for zero. RET Z ; return if so. LD A,$FF ; prepare XOR mask for sign bit JR SIGN_TO_C ; forward to SIGN_TO_C ; to put sign in carry ; (carry will become set if sign is positive) ; and then overwrite location with 1 or 0 ; as appropriate.
; Handle NOT operator ($2C)
; This overwrites the last value with 1 if it was zero else with zero ; if it was any other value. ; ; e.g. NOT 0 returns 1, NOT 1 returns 0, NOT -3 returns 0. ; ; The subroutine is also called directly from the end-tests of the comparison ; operator. mark_1AD5: not: LD A,(HL) ; get exponent byte. NEG ; negate - sets carry if non-zero. CCF ; complement so carry set if zero, else reset. JR FP_0_OR_1 ; forward to FP_0_OR_1.
; Less than zero (32)
; Destructively test if last value on calculator stack is less than zero. ; Bit 7 of second byte will be set if so. mark_1ADB: less_0: XOR A ; set xor mask to zero ; (carry will become set if sign is negative). ; transfer sign of mantissa to Carry Flag. mark_1ADC: SIGN_TO_C: INC HL ; address 2nd byte. XOR (HL) ; bit 7 of HL will be set if number is negative. DEC HL ; address 1st byte again. RLCA ; rotate bit 7 of A to carry.
; Zero or one
; This routine places an integer value zero or one at the addressed location ; of calculator stack or MEM area. The value one is written if carry is set on ; entry else zero. mark_1AE0: FP_0_OR_1: PUSH HL ; save pointer to the first byte LD B,$05 ; five bytes to do. mark_1AE3: FP_loop: LD (HL),$00 ; insert a zero. INC HL ; DJNZ FP_loop ; repeat. POP HL ; RET NC ; LD (HL),$81 ; make value 1 RET ; return.
; Handle OR operator (07)
; The Boolean OR operator. eg. X OR Y ; The result is zero if both values are zero else a non-zero value. ; ; e.g. 0 OR 0 returns 0. ; -3 OR 0 returns -3. ; 0 OR -3 returns 1. ; -3 OR 2 returns 1. ; ; A binary operation. ; On entry HL points to first operand (X) and DE to second operand (Y). mark_1AED: or: LD A,(DE) ; fetch exponent of second number AND A ; test it. RET Z ; return if zero. SCF ; set carry flag JR FP_0_OR_1 ; back to FP_0_OR_1 to overwrite the first operand ; with the value 1.
; Handle number AND number (08)
; The Boolean AND operator. ; ; e.g. -3 AND 2 returns -3. ; -3 AND 0 returns 0. ; 0 and -2 returns 0. ; 0 and 0 returns 0. ; ; Compare with OR routine above. boolean_num_and_num: LD A,(DE) ; fetch exponent of second number. AND A ; test it. RET NZ ; return if not zero. JR FP_0_OR_1 ; back to FP_0_OR_1 to overwrite the first operand ; with zero for return value.
; Handle string AND number (10)
; e.g. "YOU WIN" AND SCORE>99 will return the string if condition is true ; or the null string if false. strs_and_num: LD A,(DE) ; fetch exponent of second number. AND A ; test it. RET NZ ; return if number was not zero - the string ; is the result. ; if the number was zero (false) then the null string must be returned by ; altering the length of the string on the calculator stack to zero. PUSH DE ; save pointer to the now obsolete number ; (which will become the new STKEND) DEC DE ; point to the 5th byte of string descriptor. XOR A ; clear the accumulator. LD (DE),A ; place zero in high byte of length. DEC DE ; address low byte of length. LD (DE),A ; place zero there - now the null string. POP DE ; restore pointer - new STKEND. RET ; return.
; Perform comparison ($09-$0E, $11-$16)
; True binary operations. ; ; A single entry point is used to evaluate six numeric and six string ; comparisons. On entry, the calculator literal is in the B register and ; the two numeric values, or the two string parameters, are on the ; calculator stack. ; The individual bits of the literal are manipulated to group similar ; operations although the SUB 8 instruction does nothing useful and merely ; alters the string test bit. ; Numbers are compared by subtracting one from the other, strings are ; compared by comparing every character until a mismatch, or the end of one ; or both, is reached. ; ; Numeric Comparisons.
; The 'x>y' example is the easiest as it employs straight-thru logic. ; Number y is subtracted from x and the result tested for greater_0 yielding ; a final value 1 (true) or 0 (false). ; For 'x<y' the same logic is used but the two values are first swapped on the ; calculator stack. ; For 'x=y' NOT is applied to the subtraction result yielding true if the ; difference was zero and false with anything else. ; The first three numeric comparisons are just the opposite of the last three ; so the same processing steps are used and then a final NOT is applied. ; ; literal Test No sub 8 ExOrNot 1st RRCA exch sub ? End-Tests ; ========= ==== == ======== === ======== ======== ==== === = === === === ; num_l_eql x<=y 09 00000001 dec 00000000 00000000 ---- x-y ? --- >0? NOT ; num_gr_eql x>=y 0A 00000010 dec 00000001 10000000c swap y-x ? --- >0? NOT ; nums_neql x<>y 0B 00000011 dec 00000010 00000001 ---- x-y ? NOT --- NOT ; num_grtr x>y 0C 00000100 - 00000100 00000010 ---- x-y ? --- >0? --- ; num_less x<y 0D 00000101 - 00000101 10000010c swap y-x ? --- >0? --- ; nums_eql x=y 0E 00000110 - 00000110 00000011 ---- x-y ? NOT --- --- ; ; comp -> C/F ; ==== === ; str_l_eql x$<=y$ 11 00001001 dec 00001000 00000100 ---- x$y$ 0 !or >0? NOT ; str_gr_eql x$>=y$ 12 00001010 dec 00001001 10000100c swap y$x$ 0 !or >0? NOT ; strs_neql x$<>y$ 13 00001011 dec 00001010 00000101 ---- x$y$ 0 !or >0? NOT ; str_grtr x$>y$ 14 00001100 - 00001100 00000110 ---- x$y$ 0 !or >0? --- ; str_less x$<y$ 15 00001101 - 00001101 10000110c swap y$x$ 0 !or >0? --- ; strs_eql x$=y$ 16 00001110 - 00001110 00000111 ---- x$y$ 0 !or >0? --- ; ; String comparisons are a little different in that the eql/neql carry flag ; from the 2nd RRCA is, as before, fed into the first of the end tests but ; along the way it gets modified by the comparison process. The result on the ; stack always starts off as zero and the carry fed in determines if NOT is ; applied to it. So the only time the greater-0 test is applied is if the ; stack holds zero which is not very efficient as the test will always yield ; zero. The most likely explanation is that there were once separate end tests ; for numbers and strings. ; $1B03 SAME ADDRESS FOR MULTIPLE ROUTINES ??? num_l_eql: num_gr_eql: nums_neql: num_grtr: num_less: nums_eql: str_l_eql: str_gr_eql: strs_neql: str_grtr: str_less: strs_eql: num_lt_eql: #if ORIGINAL mark_1B03: LD A,B ; transfer literal to accumulator. SUB $08 ; subtract eight - which is not useful. #else LD A,B ; transfer literal to accumulator. ;; SUB $08 ; subtract eight - which is not useful. #endif BIT 2,A ; isolate '>', '<', '='. JR NZ,EX_OR_NOT ; skip to EX_OR_NOT with these. DEC A ; else make $00-$02, $08-$0A to match bits 0-2. EX_OR_NOT: #if ORIGINAL mark_1B0B: #endif RRCA ; the first RRCA sets carry for a swap. JR NC,NUM_OR_STR ; forward to NUM_OR_STR with other 8 cases ; for the other 4 cases the two values on the calculator stack are exchanged. PUSH AF ; save A and carry. PUSH HL ; save HL - pointer to first operand. ; (DE points to second operand). CALL exchange ; routine exchange swaps the two values. ; (HL = second operand, DE = STKEND) POP DE ; DE = first operand EX DE,HL ; as we were. POP AF ; restore A and carry. ; Note. it would be better if the 2nd RRCA preceded the string test. ; It would save two duplicate bytes and if we also got rid of that sub 8 ; at the beginning we wouldn't have to alter which bit we test. NUM_OR_STR: #if ORIGINAL mark_1B16: BIT 2,A ; test if a string comparison. JR NZ,STRINGS ; forward to STRINGS if so. ; continue with numeric comparisons. RRCA ; 2nd RRCA causes eql/neql to set carry. PUSH AF ; save A and carry #else RRCA ;+ causes 'eql/neql' to set carry. PUSH AF ;+ save the carry flag. BIT 2,A ; test if a string comparison. JR NZ,STRINGS ; forward to STRINGS if so. #endif CALL SUBTRACT ; leaves result on stack. JR END_TESTS ; forward to END_TESTS ; ___ STRINGS: #if ORIGINAL mark_1B21: RRCA ; 2nd RRCA causes eql/neql to set carry. PUSH AF ; save A and carry. #else ;; RRCA ; 2nd RRCA causes eql/neql to set carry. ;; PUSH AF ; save A and carry. #endif CALL STK_FETCH ; gets 2nd string params PUSH DE ; save start2 *. PUSH BC ; and the length. CALL STK_FETCH ; gets 1st string ; parameters - start in DE, length in BC. POP HL ; restore length of second to HL. ; A loop is now entered to compare, by subtraction, each corresponding character ; of the strings. For each successful match, the pointers are incremented and ; the lengths decreased and the branch taken back to here. If both string ; remainders become null at the same time, then an exact match exists. #if ORIGINAL mark_1B2C: #endif BYTE_COMP: LD A,H ; test if the second string OR L ; is the null string and hold flags. EX (SP),HL ; put length2 on stack, bring start2 to HL *. LD A,B ; hi byte of length1 to A JR NZ,SEC_PLUS ; forward to SEC_PLUS if second not null. OR C ; test length of first string. #if ORIGINAL mark_1B33: #endif SECOND_LOW: POP BC ; pop the second length off stack. JR Z,BOTH_NULL ; forward if first string is also ; of zero length. ; the true condition - first is longer than second (SECOND_LESS) POP AF ; restore carry (set if eql/neql) CCF ; complement carry flag. ; Note. equality becomes false. ; Inequality is true. By swapping or applying ; a terminal 'not', all comparisons have been ; manipulated so that this is success path. JR STR_TEST ; forward to leave via STR_TEST ; ___ ; the branch was here with a match #if ORIGINAL mark_1B3A: #endif BOTH_NULL: POP AF ; restore carry - set for eql/neql JR STR_TEST ; forward to STR_TEST ; ___ ; the branch was here when 2nd string not null and low byte of first is yet ; to be tested. mark_1B3D: SEC_PLUS: OR C ; test the length of first string. JR Z,FRST_LESS ; forward to FRST_LESS if length is zero. ; both strings have at least one character left. LD A,(DE) ; fetch character of first string. SUB (HL) ; subtract with that of 2nd string. JR C,FRST_LESS ; forward to FRST_LESS if carry set JR NZ,SECOND_LOW ; back to SECOND_LOW and then STR_TEST ; if not exact match. DEC BC ; decrease length of 1st string. INC DE ; increment 1st string pointer. INC HL ; increment 2nd string pointer. EX (SP),HL ; swap with length on stack DEC HL ; decrement 2nd string length JR BYTE_COMP ; back to BYTE_COMP ; ___ ; the false condition. mark_1B4D: FRST_LESS: POP BC ; discard length POP AF ; pop A AND A ; clear the carry for false result. ; ___ ; exact match and x$>y$ rejoin here mark_1B50: STR_TEST: PUSH AF ; save A and carry RST _FP_CALC ;; DEFB __stk_zero ;; an initial false value. DEFB __end_calc ;; ; both numeric and string paths converge here. mark_1B54: END_TESTS: POP AF ; pop carry - will be set if eql/neql PUSH AF ; save it again. CALL C,not ; sets true(1) if equal(0) ; or, for strings, applies true result. CALL greater_0 ; ?????????? POP AF ; pop A RRCA ; the third RRCA - test for '<=', '>=' or '<>'. CALL NC,not ; apply a terminal NOT if so. RET ; return.
; String concatenation ($17)
; This literal combines two strings into one e.g. LET A$ = B$ + C$ ; The two parameters of the two strings to be combined are on the stack. mark_1B62: strs_add: CALL STK_FETCH ; fetches string parameters ; and deletes calculator stack entry. PUSH DE ; save start address. PUSH BC ; and length. CALL STK_FETCH ; for first string POP HL ; re-fetch first length PUSH HL ; and save again PUSH DE ; save start of second string PUSH BC ; and its length. ADD HL,BC ; add the two lengths. LD B,H ; transfer to BC LD C,L ; and create RST _BC_SPACES ; BC_SPACES in workspace. ; DE points to start of space. CALL STK_STO_STR ; stores parameters ; of new string updating STKEND. POP BC ; length of first POP HL ; address of start #if ORIGINAL LD A,B ; test for OR C ; zero length. JR Z,OTHER_STR ; to OTHER_STR if null string LDIR ; copy string to workspace. #else CALL COND_MV ;+ a conditional (NZ) ldir routine. #endif mark_1B7D: OTHER_STR: POP BC ; now second length POP HL ; and start of string #if ORIGINAL LD A,B ; test this one OR C ; for zero length JR Z,STACK_POINTERS ; skip forward to STACK_POINTERS if so as complete. LDIR ; else copy the bytes. ; and continue into next routine which ; sets the calculator stack pointers. #else CALL COND_MV ;+ a conditional (NZ) ldir routine. #endif
; Check stack pointers
; Register DE is set to STKEND and HL, the result pointer, is set to five ; locations below this. ; This routine is used when it is inconvenient to save these values at the ; time the calculator stack is manipulated due to other activity on the ; machine stack. ; This routine is also used to terminate the VAL routine for ; the same reason and to initialize the calculator stack at the start of ; the CALCULATE routine. mark_1B85: STACK_POINTERS: LD HL,(STKEND) ; fetch STKEND value from system variable. LD DE,-5 PUSH HL ; push STKEND value. ADD HL,DE ; subtract 5 from HL. POP DE ; pop STKEND to DE. RET ; return.
; Handle CHR$ (2B)
; This function returns a single character string that is a result of ; converting a number in the range 0-255 to a string e.g. CHR$ 38 = "A". ; Note. the ZX81 does not have an ASCII character set. mark_1B8F: chr_dollar: CALL FP_TO_A ; puts the number in A. JR C,REPORT_Bd ; forward if overflow JR NZ,REPORT_Bd ; forward if negative #if ORIGINAL PUSH AF ; save the argument. #endif LD BC,1 ; one space required. RST _BC_SPACES ; BC_SPACES makes DE point to start #if ORIGINAL POP AF ; restore the number. #endif LD (DE),A ; and store in workspace #if ORIGINAL CALL STK_STO_STR ; stacks descriptor. EX DE,HL ; make HL point to result and DE to STKEND. RET ; return. #else JR str_STK ;+ relative jump to similar sequence in str$. #endif ; ___ mark_1BA2: REPORT_Bd: RST _ERROR_1 DEFB $0A ; Error Report: Integer out of range
; Handle VAL ($1A)
; VAL treats the characters in a string as a numeric expression. ; e.g. VAL "2.3" = 2.3, VAL "2+4" = 6, VAL ("2" + "4") = 24. val: #if ORIGINAL mark_1BA4: LD HL,(CH_ADD) ; fetch value of system variable CH_ADD #else RST _GET_CHAR ;+ shorter way to fetch CH_ADD. #endif PUSH HL ; and save on the machine stack. CALL STK_FETCH ; fetches the string operand ; from calculator stack. PUSH DE ; save the address of the start of the string. INC BC ; increment the length for a carriage return. RST _BC_SPACES ; BC_SPACES creates the space in workspace. POP HL ; restore start of string to HL. LD (CH_ADD),DE ; load CH_ADD with start DE in workspace. PUSH DE ; save the start in workspace LDIR ; copy string from program or variables or ; workspace to the workspace area. EX DE,HL ; end of string + 1 to HL DEC HL ; decrement HL to point to end of new area. LD (HL),ZX_NEWLINE ; insert a carriage return at end. ; ZX81 has a non-ASCII character set RES 7,(IY+FLAGS-RAMBASE) ; signal checking syntax. CALL CLASS_6 ; evaluates string ; expression and checks for integer result. CALL CHECK_2 ; checks for carriage return. POP HL ; restore start of string in workspace. LD (CH_ADD),HL ; set CH_ADD to the start of the string again. SET 7,(IY+FLAGS-RAMBASE) ; signal running program. CALL SCANNING ; evaluates the string ; in full leaving result on calculator stack. POP HL ; restore saved character address in program. LD (CH_ADD),HL ; and reset the system variable CH_ADD. JR STACK_POINTERS ; back to exit via STACK_POINTERS. ; resetting the calculator stack pointers ; HL and DE from STKEND as it wasn't possible ; to preserve them during this routine.
; Handle STR$ (2A)
; This function returns a string representation of a numeric argument. ; The method used is to trick the PRINT_FP routine into thinking it ; is writing to a collapsed display file when in fact it is writing to ; string workspace. ; If there is already a newline at the intended print position and the ; column count has not been reduced to zero then the print routine ; assumes that there is only 1K of RAM and the screen memory, like the rest ; of dynamic memory, expands as necessary using calls to the ONE_SPACE ; routine. The screen is character-mapped not bit-mapped. mark_1BD5: str_dollar: LD BC,1 ; create an initial byte in workspace RST _BC_SPACES ; using BC_SPACES restart. LD (HL),ZX_NEWLINE ; place a carriage return there. LD HL,(S_POSN) ; fetch value of S_POSN column/line PUSH HL ; and preserve on stack. LD L,$FF ; make column value high to create a ; contrived buffer of length 254. LD (S_POSN),HL ; and store in system variable S_POSN. LD HL,(DF_CC) ; fetch value of DF_CC PUSH HL ; and preserve on stack also. LD (DF_CC),DE ; now set DF_CC which normally addresses ; somewhere in the display file to the start ; of workspace. PUSH DE ; save the start of new string. CALL PRINT_FP POP DE ; retrieve start of string. LD HL,(DF_CC) ; fetch end of string from DF_CC. AND A ; prepare for true subtraction. SBC HL,DE ; subtract to give length. LD B,H ; and transfer to the BC LD C,L ; register. POP HL ; restore original LD (DF_CC),HL ; DF_CC value POP HL ; restore original LD (S_POSN),HL ; S_POSN values. #if ORIGINAL #else str_STK: ; New entry-point to exploit similarities and save 3 bytes of code. #endif CALL STK_STO_STR ; stores the string ; descriptor on the calculator stack. EX DE,HL ; HL = last value, DE = STKEND. RET ; return.
; THE 'CODE' FUNCTION
; (offset $19: 'code') ; Returns the code of a character or first character of a string ; e.g. CODE "AARDVARK" = 38 (not 65 as the ZX81 does not have an ASCII ; character set). mark_1C06: code: CALL STK_FETCH ; fetch and delete the string parameters. ; DE points to the start, BC holds the length. LD A,B ; test length OR C ; of the string. JR Z,STK_CODE ; skip with zero if the null string. LD A,(DE) ; else fetch the first character. mark_1C0E: STK_CODE: JP STACK_A ; jump back (with memory check)
; THE 'LEN' SUBROUTINE
; (offset $1b: 'len') ; Returns the length of a string. ; In Sinclair BASIC strings can be more than twenty thousand characters long ; so a sixteen-bit register is required to store the length mark_1C11: len: CALL STK_FETCH ; fetch and delete the ; string parameters from the calculator stack. ; register BC now holds the length of string. JP STACK_BC ; jump back to save result on the ; calculator stack (with memory check).
; THE 'DECREASE THE COUNTER' SUBROUTINE
; (offset $31: 'dec_jr_nz') ; The calculator has an instruction that decrements a single-byte ; pseudo-register and makes consequential relative jumps just like ; the Z80's DJNZ instruction. mark_1C17: dec_jr_nz: EXX ; switch in set that addresses code PUSH HL ; save pointer to offset byte LD HL,BERG ; address BERG in system variables DEC (HL) ; decrement it POP HL ; restore pointer JR NZ,JUMP_2 ; to JUMP_2 if not zero INC HL ; step past the jump length. EXX ; switch in the main set. RET ; return. ; Note. as a general rule the calculator avoids using the IY register ; otherwise the cumbersome 4 instructions in the middle could be replaced by ; dec (iy+$xx) - using three instruction bytes instead of six.
; THE 'JUMP' SUBROUTINE
; (Offset $2F; 'jump') ; This enables the calculator to perform relative jumps just like ; the Z80 chip's JR instruction. ; This is one of the few routines to be polished for the ZX Spectrum. ; See, without looking at the ZX Spectrum ROM, if you can get rid of the ; relative jump. mark_1C23: jump: EXX ;switch in pointer set JUMP_2: LD E,(HL) ; the jump byte 0-127 forward, 128-255 back. #if ORIGINAL mark_1C24: XOR A ; clear accumulator. BIT 7,E ; test if negative jump JR Z,JUMP_3 ; skip, if positive CPL ; else change to $FF. #else ; Note. Elegance from the ZX Spectrum. LD A,E ;+ RLA ;+ SBC A,A ;+ #endif mark_1C2B: JUMP_3: LD D,A ; transfer to high byte. ADD HL,DE ; advance calculator pointer forward or back. EXX ; switch out pointer set. RET ; return.
; THE 'JUMP ON TRUE' SUBROUTINE
; (Offset $00; 'jump_true') ; This enables the calculator to perform conditional relative jumps ; dependent on whether the last test gave a true result ; On the ZX81, the exponent will be zero for zero or else $81 for one. mark_1C2F: jump_true: LD A,(DE) ; collect exponent byte AND A ; is result 0 or 1 ? JR NZ,jump ; back to JUMP if true (1). EXX ; else switch in the pointer set. INC HL ; step past the jump length. EXX ; switch in the main set. RET ; return.
; THE 'MODULUS' SUBROUTINE
; ( Offset $2E: 'n_mod_m' ) ; ( i1, i2 -- i3, i4 ) ; The subroutine calculate N mod M where M is the positive integer, the ; 'last value' on the calculator stack and N is the integer beneath. ; The subroutine returns the integer quotient as the last value and the ; remainder as the value beneath. ; e.g. 17 MOD 3 = 5 remainder 2 ; It is invoked during the calculation of a random number and also by ; the PRINT_FP routine. mark_1C37: n_mod_m: RST _FP_CALC ;; 17, 3. DEFB __st_mem_0 ;; 17, 3. DEFB __delete ;; 17. DEFB __duplicate ;; 17, 17. DEFB __get_mem_0 ;; 17, 17, 3. DEFB __division ;; 17, 17/3. DEFB __int ;; 17, 5. DEFB __get_mem_0 ;; 17, 5, 3. DEFB __exchange ;; 17, 3, 5. DEFB __st_mem_0 ;; 17, 3, 5. DEFB __multiply ;; 17, 15. DEFB __subtract ;; 2. DEFB __get_mem_0 ;; 2, 5. DEFB __end_calc ;; 2, 5. RET ; return.
; THE 'INTEGER' FUNCTION
; (offset $24: 'int') ; This function returns the integer of x, which is just the same as truncate ; for positive numbers. The truncate literal truncates negative numbers ; upwards so that -3.4 gives -3 whereas the BASIC INT function has to ; truncate negative numbers down so that INT -3.4 is 4. ; It is best to work through using, say, plus or minus 3.4 as examples. mark_1C46: int: RST _FP_CALC ;; x. (= 3.4 or -3.4). DEFB __duplicate ;; x, x. DEFB __less_0 ;; x, (1/0) DEFB __jump_true ;; x, (1/0) DEFB int - $ ;; X_NEG DEFB __truncate ;; trunc 3.4 = 3. DEFB __end_calc ;; 3. RET ; return with + int x on stack. mark_1C4E: X_NEG: DEFB __duplicate ;; -3.4, -3.4. DEFB __truncate ;; -3.4, -3. DEFB __st_mem_0 ;; -3.4, -3. DEFB __subtract ;; -.4 DEFB __get_mem_0 ;; -.4, -3. DEFB __exchange ;; -3, -.4. DEFB __not ;; -3, (0). DEFB __jump_true ;; -3. DEFB EXIT - $ ;; -3. DEFB __stk_one ;; -3, 1. DEFB __subtract ;; -4. mark_1C59: EXIT: DEFB __end_calc ;; -4. RET ; return.
; Exponential (23)
; ; mark_1C5B: exp: RST _FP_CALC ;; DEFB __stk_data ;; DEFB $F1 ;;Exponent: $81, Bytes: 4 DEFB $38,$AA,$3B,$29 ;; DEFB __multiply ;; DEFB __duplicate ;; DEFB __int ;; DEFB $C3 ;;st_mem_3 DEFB __subtract ;; DEFB __duplicate ;; DEFB __addition ;; DEFB __stk_one ;; DEFB __subtract ;; DEFB __series_08 ;; DEFB $13 ;;Exponent: $63, Bytes: 1 DEFB $36 ;;(+00,+00,+00) DEFB $58 ;;Exponent: $68, Bytes: 2 DEFB $65,$66 ;;(+00,+00) DEFB $9D ;;Exponent: $6D, Bytes: 3 DEFB $78,$65,$40 ;;(+00) DEFB $A2 ;;Exponent: $72, Bytes: 3 DEFB $60,$32,$C9 ;;(+00) DEFB $E7 ;;Exponent: $77, Bytes: 4 DEFB $21,$F7,$AF,$24 ;; DEFB $EB ;;Exponent: $7B, Bytes: 4 DEFB $2F,$B0,$B0,$14 ;; DEFB $EE ;;Exponent: $7E, Bytes: 4 DEFB $7E,$BB,$94,$58 ;; DEFB $F1 ;;Exponent: $81, Bytes: 4 DEFB $3A,$7E,$F8,$CF ;; DEFB $E3 ;;get_mem_3 DEFB __end_calc ;; CALL FP_TO_A JR NZ,N_NEGTV JR C,REPORT_6b ADD A,(HL) ; JR NC,RESULT_OK mark_1C99: REPORT_6b: RST _ERROR_1 DEFB $05 ; Error Report: Number too big mark_1C9B: N_NEGTV: JR C,RESULT_ZERO SUB (HL) ; JR NC,RESULT_ZERO NEG ; Negate mark_1CA2: RESULT_OK: LD (HL),A ; RET ; return. mark_1CA4: RESULT_ZERO: RST _FP_CALC ;; DEFB __delete ;; DEFB __stk_zero ;; DEFB __end_calc ;; RET ; return.
; THE 'NATURAL LOGARITHM' FUNCTION
; (offset $22: 'ln') ; Like the ZX81 itself, 'natural' logarithms came from Scotland. ; They were devised in 1614 by well-traveled Scotsman John Napier who noted ; "Nothing doth more molest and hinder calculators than the multiplications, ; divisions, square and cubical extractions of great numbers". ; ; Napier's logarithms enabled the above operations to be accomplished by ; simple addition and subtraction simplifying the navigational and ; astronomical calculations which beset his age. ; Napier's logarithms were quickly overtaken by logarithms to the base 10 ; devised, in conjunction with Napier, by Henry Briggs a Cambridge-educated ; professor of Geometry at Oxford University. These simplified the layout ; of the tables enabling humans to easily scale calculations. ; ; It is only recently with the introduction of pocket calculators and ; computers like the ZX81 that natural logarithms are once more at the fore, ; although some computers retain logarithms to the base ten. ; 'Natural' logarithms are powers to the base 'e', which like 'pi' is a ; naturally occurring number in branches of mathematics. ; Like 'pi' also, 'e' is an irrational number and starts 2.718281828... ; ; The tabular use of logarithms was that to multiply two numbers one looked ; up their two logarithms in the tables, added them together and then looked ; for the result in a table of antilogarithms to give the desired product. ; ; The EXP function is the BASIC equivalent of a calculator's 'antiln' function ; and by picking any two numbers, 1.72 and 6.89 say, ; 10 PRINT EXP ( LN 1.72 + LN 6.89 ) ; will give just the same result as ; 20 PRINT 1.72 * 6.89. ; Division is accomplished by subtracting the two logs. ; ; Napier also mentioned "square and cubicle extractions". ; To raise a number to the power 3, find its 'ln', multiply by 3 and find the ; 'antiln'. e.g. PRINT EXP( LN 4 * 3 ) gives 64. ; Similarly to find the n'th root divide the logarithm by 'n'. ; The ZX81 ROM used PRINT EXP ( LN 9 / 2 ) to find the square root of the ; number 9. The Napieran square root function is just a special case of ; the 'to_power' function. A cube root or indeed any root/power would be just ; as simple. ; First test that the argument to LN is a positive, non-zero number. mark_1CA9: ln: RST _FP_CALC ;; DEFB __duplicate ;; DEFB __greater_0 ;; DEFB __jump_true ;; DEFB VALID - $ ;;to VALID DEFB __end_calc ;; mark_1CAF: REPORT_Ab: RST _ERROR_1 DEFB $09 ; Error Report: Invalid argument VALID: #if ORIGINAL mark_1CB1: DEFB __stk_zero ;; Note. not necessary. DEFB __delete ;; #endif DEFB __end_calc ;; LD A,(HL) ; LD (HL),$80 ; CALL STACK_A RST _FP_CALC ;; DEFB __stk_data ;; DEFB $38 ;;Exponent: $88, Bytes: 1 DEFB $00 ;;(+00,+00,+00) DEFB __subtract ;; DEFB __exchange ;; DEFB __duplicate ;; DEFB __stk_data ;; DEFB $F0 ;;Exponent: $80, Bytes: 4 DEFB $4C,$CC,$CC,$CD ;; DEFB __subtract ;; DEFB __greater_0 ;; DEFB __jump_true ;; DEFB GRE_8 - $ ;; DEFB __exchange ;; DEFB __stk_one ;; DEFB __subtract ;; DEFB __exchange ;; DEFB __end_calc ;; INC (HL) ; RST _FP_CALC ;; mark_1CD2: GRE_8: DEFB __exchange ;; DEFB __stk_data ;; DEFB $F0 ;;Exponent: $80, Bytes: 4 DEFB $31,$72,$17,$F8 ;; DEFB __multiply ;; DEFB __exchange ;; DEFB __stk_half ;; DEFB __subtract ;; DEFB __stk_half ;; DEFB __subtract ;; DEFB __duplicate ;; DEFB __stk_data ;; DEFB $32 ;;Exponent: $82, Bytes: 1 DEFB $20 ;;(+00,+00,+00) DEFB __multiply ;; DEFB __stk_half ;; DEFB __subtract ;; DEFB __series_0C ;; DEFB $11 ;;Exponent: $61, Bytes: 1 DEFB $AC ;;(+00,+00,+00) DEFB $14 ;;Exponent: $64, Bytes: 1 DEFB $09 ;;(+00,+00,+00) DEFB $56 ;;Exponent: $66, Bytes: 2 DEFB $DA,$A5 ;;(+00,+00) DEFB $59 ;;Exponent: $69, Bytes: 2 DEFB $30,$C5 ;;(+00,+00) DEFB $5C ;;Exponent: $6C, Bytes: 2 DEFB $90,$AA ;;(+00,+00) DEFB $9E ;;Exponent: $6E, Bytes: 3 DEFB $70,$6F,$61 ;;(+00) DEFB $A1 ;;Exponent: $71, Bytes: 3 DEFB $CB,$DA,$96 ;;(+00) DEFB $A4 ;;Exponent: $74, Bytes: 3 DEFB $31,$9F,$B4 ;;(+00) DEFB $E7 ;;Exponent: $77, Bytes: 4 DEFB $A0,$FE,$5C,$FC ;; DEFB $EA ;;Exponent: $7A, Bytes: 4 DEFB $1B,$43,$CA,$36 ;; DEFB $ED ;;Exponent: $7D, Bytes: 4 DEFB $A7,$9C,$7E,$5E ;; DEFB $F0 ;;Exponent: $80, Bytes: 4 DEFB $6E,$23,$80,$93 ;; DEFB __multiply ;; DEFB __addition ;; DEFB __end_calc ;; RET ; return.
#if ORIGINAL #else ; ------------------------------ ; THE NEW 'SQUARE ROOT' FUNCTION ; ------------------------------ ; (Offset $25: 'sqr') ; "If I have seen further, it is by standing on the shoulders of giants" - ; Sir Isaac Newton, Cambridge 1676. ; The sqr function has been re-written to use the Newton-Raphson method. ; Joseph Raphson was a student of Sir Isaac Newton at Cambridge University ; and helped publicize his work. ; Although Newton's method is centuries old, this routine, appropriately, is ; based on a FORTH word written by Steven Vickers in the Jupiter Ace manual. ; Whereas that method uses an initial guess of one, this one manipulates ; the exponent byte to obtain a better starting guess. ; First test for zero and return zero, if so, as the result. ; If the argument is negative, then produce an error. ; sqr RST _FP_CALC ;; x DEFB __st_mem_3 ;; x. (seed for guess) DEFB __end_calc ;; x. ; HL now points to exponent of argument on calculator stack. LD A,(HL) ; Test for zero argument AND A ; RET Z ; Return with zero on the calculator stack. ; Test for a positive argument INC HL ; Address byte with sign bit. BIT 7,(HL) ; Test the bit. JR NZ,REPORT_Ab ; back to REPORT_A ; 'Invalid argument' ; This guess is based on a Usenet discussion. ; Halve the exponent to achieve a good guess.(accurate with .25 16 64 etc.) LD HL,$4071 ; Address first byte of mem-3 LD A,(HL) ; fetch exponent of mem-3 XOR $80 ; toggle sign of exponent of mem-3 SRA A ; shift right, bit 7 unchanged. INC A ; JR Z,ASIS ; forward with say .25 -> .5 JP P,ASIS ; leave increment if value > .5 DEC A ; restore to shift only. ASIS XOR $80 ; restore sign. LD (HL),A ; and put back 'halved' exponent. ; Now re-enter the calculator. RST 28H ;; FP-CALC x SLOOP DEFB __duplicate ;; x,x. DEFB __get_mem_3 ;; x,x,guess DEFB __st_mem_4 ;; x,x,guess DEFB __division ;; x,x/guess. DEFB __get_mem_3 ;; x,x/guess,guess DEFB __addition ;; x,x/guess+guess DEFB __stk_half ;; x,x/guess+guess,.5 DEFB __multiply ;; x,(x/guess+guess)*.5 DEFB __st_mem_3 ;; x,newguess DEFB __get_mem_4 ;; x,newguess,oldguess DEFB __subtract ;; x,newguess-oldguess DEFB __abs ;; x,difference. DEFB __greater_0 ;; x,(0/1). DEFB __jump_true ;; x. DEFB SLOOP - $ ;; x. DEFB __delete ;; . DEFB __get_mem_3 ;; retrieve final guess. DEFB __end_calc ;; sqr x. RET ; return with square root on stack ; or in ZX81 BASIC ; ; 5 PRINT "NEWTON RAPHSON SQUARE ROOTS" ; 10 INPUT "NUMBER ";N ; 20 INPUT "GUESS ";G ; 30 PRINT " NUMBER "; N ;" GUESS "; G ; 40 FOR I = 1 TO 10 ; 50 LET B = N/G ; 60 LET C = B+G ; 70 LET G = C/2 ; 80 PRINT I; " VALUE "; G ; 90 NEXT I ; 100 PRINT "NAPIER METHOD"; SQR N #endif
; THE 'TRIGONOMETRIC' FUNCTIONS
; Trigonometry is rocket science. It is also used by carpenters and pyramid ; builders. ; Some uses can be quite abstract but the principles can be seen in simple ; right-angled triangles. Triangles have some special properties - ; ; 1) The sum of the three angles is always PI radians (180 degrees). ; Very helpful if you know two angles and wish to find the third. ; 2) In any right-angled triangle the sum of the squares of the two shorter ; sides is equal to the square of the longest side opposite the right-angle. ; Very useful if you know the length of two sides and wish to know the ; length of the third side. ; 3) Functions sine, cosine and tangent enable one to calculate the length ; of an unknown side when the length of one other side and an angle is ; known. ; 4) Functions arcsin, arccosine and arctan enable one to calculate an unknown ; angle when the length of two of the sides is known.
; THE 'REDUCE ARGUMENT' SUBROUTINE
; (offset $35: 'get_argt') ; ; This routine performs two functions on the angle, in radians, that forms ; the argument to the sine and cosine functions. ; First it ensures that the angle 'wraps round'. That if a ship turns through ; an angle of, say, 3*PI radians (540 degrees) then the net effect is to turn ; through an angle of PI radians (180 degrees). ; Secondly it converts the angle in radians to a fraction of a right angle, ; depending within which quadrant the angle lies, with the periodicity ; resembling that of the desired sine value. ; The result lies in the range -1 to +1. ; ; 90 deg. ; ; (pi/2) ; II +1 I ; | ; sin+ |\ | /| sin+ ; cos- | \ | / | cos+ ; tan- | \ | / | tan+ ; | \|/) | ; 180 deg. (pi) 0 |----+----|-- 0 (0) 0 degrees ; | /|\ | ; sin- | / | \ | sin- ; cos- | / | \ | cos+ ; tan+ |/ | \| tan- ; | ; III -1 IV ; (3pi/2) ; ; 270 deg. mark_1D18: get_argt: RST _FP_CALC ;; X. DEFB __stk_data ;; DEFB $EE ;;Exponent: $7E, ;;Bytes: 4 DEFB $22,$F9,$83,$6E ;; X, 1/(2*PI) DEFB __multiply ;; X/(2*PI) = fraction DEFB __duplicate ;; DEFB __stk_half ;; DEFB __addition ;; DEFB __int ;; DEFB __subtract ;; now range -.5 to .5 DEFB __duplicate ;; DEFB __addition ;; now range -1 to 1. DEFB __duplicate ;; DEFB __addition ;; now range -2 to 2. ; quadrant I (0 to +1) and quadrant IV (-1 to 0) are now correct. ; quadrant II ranges +1 to +2. ; quadrant III ranges -2 to -1. DEFB __duplicate ;; Y, Y. DEFB __abs ;; Y, abs(Y). range 1 to 2 DEFB __stk_one ;; Y, abs(Y), 1. DEFB __subtract ;; Y, abs(Y)-1. range 0 to 1 DEFB __duplicate ;; Y, Z, Z. DEFB __greater_0 ;; Y, Z, (1/0). DEFB __st_mem_0 ;; store as possible sign ;; for cosine function. DEFB __jump_true ;; DEFB Z_PLUS - $ ;; with quadrants II and III ; else the angle lies in quadrant I or IV and value Y is already correct. DEFB __delete ;; Y delete test value. DEFB __end_calc ;; Y. RET ; return. with Q1 and Q4 >>> ; The branch was here with quadrants II (0 to 1) and III (1 to 0). ; Y will hold -2 to -1 if this is quadrant III. mark_1D35: Z_PLUS: DEFB __stk_one ;; Y, Z, 1 DEFB __subtract ;; Y, Z-1. Q3 = 0 to -1 DEFB __exchange ;; Z-1, Y. DEFB __less_0 ;; Z-1, (1/0). DEFB __jump_true ;; Z-1. DEFB YNEG - $ ;; ;;if angle in quadrant III ; else angle is within quadrant II (-1 to 0) DEFB __negate ; range +1 to 0 mark_1D3C: YNEG: DEFB __end_calc ;; quadrants II and III correct. RET ; return.
; THE 'COSINE' FUNCTION
; (offset $1D: 'cos') ; Cosines are calculated as the sine of the opposite angle rectifying the ; sign depending on the quadrant rules. ; ; ; /| ; h /y| ; / |o ; / x | ; /----| ; a ; ; The cosine of angle x is the adjacent side (a) divided by the hypotenuse 1. ; However if we examine angle y then a/h is the sine of that angle. ; Since angle x plus angle y equals a right-angle, we can find angle y by ; subtracting angle x from pi/2. ; However it's just as easy to reduce the argument first and subtract the ; reduced argument from the value 1 (a reduced right-angle). ; It's even easier to subtract 1 from the angle and rectify the sign. ; In fact, after reducing the argument, the absolute value of the argument ; is used and rectified using the test result stored in mem-0 by 'get-argt' ; for that purpose. mark_1D3E: cos: RST _FP_CALC ;; angle in radians. DEFB __get_argt ;; X reduce -1 to +1 DEFB __abs ;; ABS X 0 to 1 DEFB __stk_one ;; ABS X, 1. DEFB __subtract ;; now opposite angle ;; though negative sign. DEFB __get_mem_0 ;; fetch sign indicator. DEFB __jump_true ;; DEFB C_ENT - $ ;;fwd to C_ENT ;;forward to common code if in QII or QIII DEFB __negate ;; else make positive. DEFB __jump ;; DEFB C_ENT - $ ;;fwd to C_ENT ;;with quadrants QI and QIV
; THE 'SINE' FUNCTION
; (offset $1C: 'sin') ; This is a fundamental transcendental function from which others such as cos ; and tan are directly, or indirectly, derived. ; It uses the series generator to produce Chebyshev polynomials. ; ; ; /| ; 1 / | ; / |x ; /a | ; /----| ; y ; ; The 'get-argt' function is designed to modify the angle and its sign ; in line with the desired sine value and afterwards it can launch straight ; into common code. mark_1D49: sin: RST _FP_CALC ;; angle in radians DEFB __get_argt ;; reduce - sign now correct. mark_1D4B: C_ENT: DEFB __duplicate ;; DEFB __duplicate ;; DEFB __multiply ;; DEFB __duplicate ;; DEFB __addition ;; DEFB __stk_one ;; DEFB __subtract ;; DEFB __series_06 ;; DEFB $14 ;;Exponent: $64, Bytes: 1 DEFB $E6 ;;(+00,+00,+00) DEFB $5C ;;Exponent: $6C, Bytes: 2 DEFB $1F,$0B ;;(+00,+00) DEFB $A3 ;;Exponent: $73, Bytes: 3 DEFB $8F,$38,$EE ;;(+00) DEFB $E9 ;;Exponent: $79, Bytes: 4 DEFB $15,$63,$BB,$23 ;; DEFB $EE ;;Exponent: $7E, Bytes: 4 DEFB $92,$0D,$CD,$ED ;; DEFB $F1 ;;Exponent: $81, Bytes: 4 DEFB $23,$5D,$1B,$EA ;; DEFB __multiply ;; DEFB __end_calc ;; RET ; return.
; THE 'TANGENT' FUNCTION
; (offset $1E: 'tan') ; ; Evaluates tangent x as sin(x) / cos(x). ; ; ; /| ; h / | ; / |o ; /x | ; /----| ; a ; ; The tangent of angle x is the ratio of the length of the opposite side ; divided by the length of the adjacent side. As the opposite length can ; be calculates using sin(x) and the adjacent length using cos(x) then ; the tangent can be defined in terms of the previous two functions. ; Error 6 if the argument, in radians, is too close to one like pi/2 ; which has an infinite tangent. e.g. PRINT TAN (PI/2) evaluates as 1/0. ; Similarly PRINT TAN (3*PI/2), TAN (5*PI/2) etc. mark_1D6E: tan: RST _FP_CALC ;; x. DEFB __duplicate ;; x, x. DEFB __sin ;; x, sin x. DEFB __exchange ;; sin x, x. DEFB __cos ;; sin x, cos x. DEFB __division ;; sin x/cos x (= tan x). DEFB __end_calc ;; tan x. RET ; return.
; THE 'ARCTAN' FUNCTION
; (Offset $21: 'atn') ; The inverse tangent function with the result in radians. ; This is a fundamental transcendental function from which others such as ; asn and acs are directly, or indirectly, derived. ; It uses the series generator to produce Chebyshev polynomials. mark_1D76: atn: LD A,(HL) ; fetch exponent CP $81 ; compare to that for 'one' JR C,SMALL ; forward, if less RST _FP_CALC ;; X. DEFB __stk_one ;; DEFB __negate ;; DEFB __exchange ;; DEFB __division ;; DEFB __duplicate ;; DEFB __less_0 ;; DEFB __stk_half_pi ;; DEFB __exchange ;; DEFB __jump_true ;; DEFB CASES - $ ;; DEFB __negate ;; DEFB __jump ;; DEFB CASES - $ ;; ; ___ mark_1D89: SMALL: RST _FP_CALC ;; DEFB __stk_zero ;; mark_1D8B: CASES: DEFB __exchange ;; DEFB __duplicate ;; DEFB __duplicate ;; DEFB __multiply ;; DEFB __duplicate ;; DEFB __addition ;; DEFB __stk_one ;; DEFB __subtract ;; DEFB __series_0C ;; DEFB $10 ;;Exponent: $60, Bytes: 1 DEFB $B2 ;;(+00,+00,+00) DEFB $13 ;;Exponent: $63, Bytes: 1 DEFB $0E ;;(+00,+00,+00) DEFB $55 ;;Exponent: $65, Bytes: 2 DEFB $E4,$8D ;;(+00,+00) DEFB $58 ;;Exponent: $68, Bytes: 2 DEFB $39,$BC ;;(+00,+00) DEFB $5B ;;Exponent: $6B, Bytes: 2 DEFB $98,$FD ;;(+00,+00) DEFB $9E ;;Exponent: $6E, Bytes: 3 DEFB $00,$36,$75 ;;(+00) DEFB $A0 ;;Exponent: $70, Bytes: 3 DEFB $DB,$E8,$B4 ;;(+00) DEFB $63 ;;Exponent: $73, Bytes: 2 DEFB $42,$C4 ;;(+00,+00) DEFB $E6 ;;Exponent: $76, Bytes: 4 DEFB $B5,$09,$36,$BE ;; DEFB $E9 ;;Exponent: $79, Bytes: 4 DEFB $36,$73,$1B,$5D ;; DEFB $EC ;;Exponent: $7C, Bytes: 4 DEFB $D8,$DE,$63,$BE ;; DEFB $F0 ;;Exponent: $80, Bytes: 4 DEFB $61,$A1,$B3,$0C ;; DEFB __multiply ;; DEFB __addition ;; DEFB __end_calc ;; RET ; return.
; THE 'ARCSIN' FUNCTION
; (Offset $1F: 'asn') ; The inverse sine function with result in radians. ; Derived from arctan function above. ; Error A unless the argument is between -1 and +1 inclusive. ; Uses an adaptation of the formula asn(x) = atn(x/sqr(1-x*x)) ; ; ; /| ; / | ; 1/ |x ; /a | ; /----| ; y ; ; e.g. We know the opposite side (x) and hypotenuse (1) ; and we wish to find angle a in radians. ; We can derive length y by Pythagoras and then use ATN instead. ; Since y*y + x*x = 1*1 (Pythagoras Theorem) then ; y=sqr(1-x*x) - no need to multiply 1 by itself. ; So, asn(a) = atn(x/y) ; or more fully, ; asn(a) = atn(x/sqr(1-x*x)) ; Close but no cigar. ; While PRINT ATN (x/SQR (1-x*x)) gives the same results as PRINT ASN x, ; it leads to division by zero when x is 1 or -1. ; To overcome this, 1 is added to y giving half the required angle and the ; result is then doubled. ; That is, PRINT ATN (x/(SQR (1-x*x) +1)) *2 ; ; ; . /| ; . c/ | ; . /1 |x ; . c b /a | ; ---------/----| ; 1 y ; ; By creating an isosceles triangle with two equal sides of 1, angles c and ; c are also equal. If b+c+d = 180 degrees and b+a = 180 degrees then c=a/2. ; ; A value higher than 1 gives the required error as attempting to find the ; square root of a negative number generates an error in Sinclair BASIC. mark_1DC4: asn: RST _FP_CALC ;; x. DEFB __duplicate ;; x, x. DEFB __duplicate ;; x, x, x. DEFB __multiply ;; x, x*x. DEFB __stk_one ;; x, x*x, 1. DEFB __subtract ;; x, x*x-1. DEFB __negate ;; x, 1-x*x. DEFB __sqr ;; x, sqr(1-x*x) = y. DEFB __stk_one ;; x, y, 1. DEFB __addition ;; x, y+1. DEFB __division ;; x/y+1. DEFB __atn ;; a/2 (half the angle) DEFB __duplicate ;; a/2, a/2. DEFB __addition ;; a. DEFB __end_calc ;; a. RET ; return.
; THE 'ARCCOS' FUNCTION
; (Offset $20: 'acs') ; The inverse cosine function with the result in radians. ; Error A unless the argument is between -1 and +1. ; Result in range 0 to pi. ; Derived from asn above which is in turn derived from the preceding atn. It ; could have been derived directly from atn using acs(x) = atn(sqr(1-x*x)/x). ; However, as sine and cosine are horizontal translations of each other, ; uses acs(x) = pi/2 - asn(x) ; e.g. the arccosine of a known x value will give the required angle b in ; radians. ; We know, from above, how to calculate the angle a using asn(x). ; Since the three angles of any triangle add up to 180 degrees, or pi radians, ; and the largest angle in this case is a right-angle (pi/2 radians), then ; we can calculate angle b as pi/2 (both angles) minus asn(x) (angle a). ; ;; ; /| ; 1 /b| ; / |x ; /a | ; /----| ; y mark_1DD4: acs: RST _FP_CALC ;; x. DEFB __asn ;; asn(x). DEFB __stk_half_pi ;; asn(x), pi/2. DEFB __subtract ;; asn(x) - pi/2. DEFB __negate ;; pi/2 - asn(x) = acs(x). DEFB __end_calc ;; acs(x) RET ; return. #if ORIGINAL
; THE 'SQUARE ROOT' FUNCTION
; (Offset $25: 'sqr') ; Error A if argument is negative. ; This routine is remarkable for its brevity - 7 bytes. ; ; The ZX81 code was originally 9K and various techniques had to be ; used to shoe-horn it into an 8K Rom chip. ; This routine uses Napier's method for calculating square roots which was ; devised in 1614 and calculates the value as EXP (LN 'x' * 0.5). ; ; This is a little on the slow side as it involves two polynomial series. ; A series of 12 for LN and a series of 8 for EXP. ; This was of no concern to John Napier since his tables were 'compiled forever'. mark_1DDB: sqr: RST _FP_CALC ;; x. DEFB __duplicate ;; x, x. DEFB __not ;; x, 1/0 DEFB __jump_true ;; x, (1/0). DEFB LAST - $ ;; exit if argument zero ;; with zero result. ; else continue to calculate as x ** .5 DEFB __stk_half ;; x, .5. DEFB __end_calc ;; x, .5. #endif
; THE 'EXPONENTIATION' OPERATION
; (Offset $06: 'to_power') ; This raises the first number X to the power of the second number Y. ; As with the ZX80, ; 0 ** 0 = 1 ; 0 ** +n = 0 ; 0 ** -n = arithmetic overflow. mark_1DE2: to_power: RST _FP_CALC ;; X,Y. DEFB __exchange ;; Y,X. DEFB __duplicate ;; Y,X,X. DEFB __not ;; Y,X,(1/0). DEFB __jump_true ;; DEFB XISO - $ ;;forward to XISO if X is zero. ; else X is non-zero. function 'ln' will catch a negative value of X. DEFB __ln ;; Y, LN X. DEFB __multiply ;; Y * LN X DEFB __end_calc ;; JP exp ; jump back to EXP routine. -> ; ___ ; These routines form the three simple results when the number is zero. ; begin by deleting the known zero to leave Y the power factor. mark_1DEE: XISO: DEFB __delete ;; Y. DEFB __duplicate ;; Y, Y. DEFB __not ;; Y, (1/0). DEFB __jump_true ;; DEFB ONE - $ ;; if Y is zero. ; the power factor is not zero. If negative then an error exists. DEFB __stk_zero ;; Y, 0. DEFB __exchange ;; 0, Y. DEFB __greater_0 ;; 0, (1/0). DEFB __jump_true ;; 0 DEFB LAST - $ ;; if Y was any positive ;; number. ; else force division by zero thereby raising an Arithmetic overflow error. ; There are some one and two-byte alternatives but perhaps the most formal ; might have been to use end_calc; rst 08; defb 05. ; #if ORIGINAL ; the SG ROM seems to want it the old way! #if 1 DEFB __stk_one ;; 0, 1. DEFB __exchange ;; 1, 0. DEFB __division ;; 1/0 >> error #else DEFB $34 ;+ end-calc REPORT_6c RST 08H ;+ ERROR-1 DEFB $05 ;+ Error Report: Number too big #endif ; ___ mark_1DFB: ONE: DEFB __delete ;; . DEFB __stk_one ;; 1. mark_1DFD: LAST: DEFB __end_calc ;; last value 1 or 0. RET ; return.
; THE 'SPARE LOCATIONS'
SPARE: #if ORIGINAL mark_1DFF: DEFB $FF ; That's all folks. #else mark_1DFE: L1DFE: ;; DEFB $FF, $FF ; Two spare bytes. DEFB $00, $00 ; Two spare bytes (as per the Shoulders of Giants ROM) #endif
; THE 'ZX81 CHARACTER SET'
mark_1E00: char_set ; - begins with space character. ; $00 - Character: ' ' CHR$(0) DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00000000 ; $01 - Character: mosaic CHR$(1) DEFB %11110000 DEFB %11110000 DEFB %11110000 DEFB %11110000 DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00000000 ; $02 - Character: mosaic CHR$(2) DEFB %00001111 DEFB %00001111 DEFB %00001111 DEFB %00001111 DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00000000 ; $03 - Character: mosaic CHR$(3) DEFB %11111111 DEFB %11111111 DEFB %11111111 DEFB %11111111 DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00000000 ; $04 - Character: mosaic CHR$(4) DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %11110000 DEFB %11110000 DEFB %11110000 DEFB %11110000 ; $05 - Character: mosaic CHR$(5) DEFB %11110000 DEFB %11110000 DEFB %11110000 DEFB %11110000 DEFB %11110000 DEFB %11110000 DEFB %11110000 DEFB %11110000 ; $06 - Character: mosaic CHR$(6) DEFB %00001111 DEFB %00001111 DEFB %00001111 DEFB %00001111 DEFB %11110000 DEFB %11110000 DEFB %11110000 DEFB %11110000 ; $07 - Character: mosaic CHR$(7) DEFB %11111111 DEFB %11111111 DEFB %11111111 DEFB %11111111 DEFB %11110000 DEFB %11110000 DEFB %11110000 DEFB %11110000 ; $08 - Character: mosaic CHR$(8) DEFB %10101010 DEFB %01010101 DEFB %10101010 DEFB %01010101 DEFB %10101010 DEFB %01010101 DEFB %10101010 DEFB %01010101 ; $09 - Character: mosaic CHR$(9) DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %10101010 DEFB %01010101 DEFB %10101010 DEFB %01010101 ; $0A - Character: mosaic CHR$(10) DEFB %10101010 DEFB %01010101 DEFB %10101010 DEFB %01010101 DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00000000 ; $0B - Character: '"' CHR$(11) DEFB %00000000 DEFB %00100100 DEFB %00100100 DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00000000 ; $0C - Character: £ CHR$(12) DEFB %00000000 DEFB %00011100 DEFB %00100010 DEFB %01111000 DEFB %00100000 DEFB %00100000 DEFB %01111110 DEFB %00000000 ; $0D - Character: '$' CHR$(13) DEFB %00000000 DEFB %00001000 DEFB %00111110 DEFB %00101000 DEFB %00111110 DEFB %00001010 DEFB %00111110 DEFB %00001000 ; $0E - Character: ':' CHR$(14) DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00010000 DEFB %00000000 DEFB %00000000 DEFB %00010000 DEFB %00000000 ; $0F - Character: '?' CHR$(15) DEFB %00000000 DEFB %00111100 DEFB %01000010 DEFB %00000100 DEFB %00001000 DEFB %00000000 DEFB %00001000 DEFB %00000000 ; $10 - Character: '(' CHR$(16) DEFB %00000000 DEFB %00000100 DEFB %00001000 DEFB %00001000 DEFB %00001000 DEFB %00001000 DEFB %00000100 DEFB %00000000 ; $11 - Character: ')' CHR$(17) DEFB %00000000 DEFB %00100000 DEFB %00010000 DEFB %00010000 DEFB %00010000 DEFB %00010000 DEFB %00100000 DEFB %00000000 ; $12 - Character: '>' CHR$(18) DEFB %00000000 DEFB %00000000 DEFB %00010000 DEFB %00001000 DEFB %00000100 DEFB %00001000 DEFB %00010000 DEFB %00000000 ; $13 - Character: '<' CHR$(19) DEFB %00000000 DEFB %00000000 DEFB %00000100 DEFB %00001000 DEFB %00010000 DEFB %00001000 DEFB %00000100 DEFB %00000000 ; $14 - Character: '=' CHR$(20) DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00111110 DEFB %00000000 DEFB %00111110 DEFB %00000000 DEFB %00000000 ; $15 - Character: '+' CHR$(21) DEFB %00000000 DEFB %00000000 DEFB %00001000 DEFB %00001000 DEFB %00111110 DEFB %00001000 DEFB %00001000 DEFB %00000000 ; $16 - Character: '-' CHR$(22) DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00111110 DEFB %00000000 DEFB %00000000 DEFB %00000000 ; $17 - Character: '*' CHR$(23) DEFB %00000000 DEFB %00000000 DEFB %00010100 DEFB %00001000 DEFB %00111110 DEFB %00001000 DEFB %00010100 DEFB %00000000 ; $18 - Character: '/' CHR$(24) DEFB %00000000 DEFB %00000000 DEFB %00000010 DEFB %00000100 DEFB %00001000 DEFB %00010000 DEFB %00100000 DEFB %00000000 ; $19 - Character: ';' CHR$(25) DEFB %00000000 DEFB %00000000 DEFB %00010000 DEFB %00000000 DEFB %00000000 DEFB %00010000 DEFB %00010000 DEFB %00100000 ; $1A - Character: ',' CHR$(26) DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00001000 DEFB %00001000 DEFB %00010000 ; $1B - Character: '"' CHR$(27) DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00000000 DEFB %00011000 DEFB %00011000 DEFB %00000000 ; $1C - Character: '0' CHR$(28) DEFB %00000000 DEFB %00111100 DEFB %01000110 DEFB %01001010 DEFB %01010010 DEFB %01100010 DEFB %00111100 DEFB %00000000 ; $1D - Character: '1' CHR$(29) DEFB %00000000 DEFB %00011000 DEFB %00101000 DEFB %00001000 DEFB %00001000 DEFB %00001000 DEFB %00111110 DEFB %00000000 ; $1E - Character: '2' CHR$(30) DEFB %00000000 DEFB %00111100 DEFB %01000010 DEFB %00000010 DEFB %00111100 DEFB %01000000 DEFB %01111110 DEFB %00000000 ; $1F - Character: '3' CHR$(31) DEFB %00000000 DEFB %00111100 DEFB %01000010 DEFB %00001100 DEFB %00000010 DEFB %01000010 DEFB %00111100 DEFB %00000000 ; $20 - Character: '4' CHR$(32) DEFB %00000000 DEFB %00001000 DEFB %00011000 DEFB %00101000 DEFB %01001000 DEFB %01111110 DEFB %00001000 DEFB %00000000 ; $21 - Character: '5' CHR$(33) DEFB %00000000 DEFB %01111110 DEFB %01000000 DEFB %01111100 DEFB %00000010 DEFB %01000010 DEFB %00111100 DEFB %00000000 ; $22 - Character: '6' CHR$(34) DEFB %00000000 DEFB %00111100 DEFB %01000000 DEFB %01111100 DEFB %01000010 DEFB %01000010 DEFB %00111100 DEFB %00000000 ; $23 - Character: '7' CHR$(35) DEFB %00000000 DEFB %01111110 DEFB %00000010 DEFB %00000100 DEFB %00001000 DEFB %00010000 DEFB %00010000 DEFB %00000000 ; $24 - Character: '8' CHR$(36) DEFB %00000000 DEFB %00111100 DEFB %01000010 DEFB %00111100 DEFB %01000010 DEFB %01000010 DEFB %00111100 DEFB %00000000 ; $25 - Character: '9' CHR$(37) DEFB %00000000 DEFB %00111100 DEFB %01000010 DEFB %01000010 DEFB %00111110 DEFB %00000010 DEFB %00111100 DEFB %00000000 ; $26 - Character: 'A' CHR$(38) DEFB %00000000 DEFB %00111100 DEFB %01000010 DEFB %01000010 DEFB %01111110 DEFB %01000010 DEFB %01000010 DEFB %00000000 ; $27 - Character: 'B' CHR$(39) DEFB %00000000 DEFB %01111100 DEFB %01000010 DEFB %01111100 DEFB %01000010 DEFB %01000010 DEFB %01111100 DEFB %00000000 ; $28 - Character: 'C' CHR$(40) DEFB %00000000 DEFB %00111100 DEFB %01000010 DEFB %01000000 DEFB %01000000 DEFB %01000010 DEFB %00111100 DEFB %00000000 ; $29 - Character: 'D' CHR$(41) DEFB %00000000 DEFB %01111000 DEFB %01000100 DEFB %01000010 DEFB %01000010 DEFB %01000100 DEFB %01111000 DEFB %00000000 ; $2A - Character: 'E' CHR$(42) DEFB %00000000 DEFB %01111110 DEFB %01000000 DEFB %01111100 DEFB %01000000 DEFB %01000000 DEFB %01111110 DEFB %00000000 ; $2B - Character: 'F' CHR$(43) DEFB %00000000 DEFB %01111110 DEFB %01000000 DEFB %01111100 DEFB %01000000 DEFB %01000000 DEFB %01000000 DEFB %00000000 ; $2C - Character: 'G' CHR$(44) DEFB %00000000 DEFB %00111100 DEFB %01000010 DEFB %01000000 DEFB %01001110 DEFB %01000010 DEFB %00111100 DEFB %00000000 ; $2D - Character: 'H' CHR$(45) DEFB %00000000 DEFB %01000010 DEFB %01000010 DEFB %01111110 DEFB %01000010 DEFB %01000010 DEFB %01000010 DEFB %00000000 ; $2E - Character: 'I' CHR$(46) DEFB %00000000 DEFB %00111110 DEFB %00001000 DEFB %00001000 DEFB %00001000 DEFB %00001000 DEFB %00111110 DEFB %00000000 ; $2F - Character: 'J' CHR$(47) DEFB %00000000 DEFB %00000010 DEFB %00000010 DEFB %00000010 DEFB %01000010 DEFB %01000010 DEFB %00111100 DEFB %00000000 ; $30 - Character: 'K' CHR$(48) DEFB %00000000 DEFB %01000100 DEFB %01001000 DEFB %01110000 DEFB %01001000 DEFB %01000100 DEFB %01000010 DEFB %00000000 ; $31 - Character: 'L' CHR$(49) DEFB %00000000 DEFB %01000000 DEFB %01000000 DEFB %01000000 DEFB %01000000 DEFB %01000000 DEFB %01111110 DEFB %00000000 ; $32 - Character: 'M' CHR$(50) DEFB %00000000 DEFB %01000010 DEFB %01100110 DEFB %01011010 DEFB %01000010 DEFB %01000010 DEFB %01000010 DEFB %00000000 ; $33 - Character: 'N' CHR$(51) DEFB %00000000 DEFB %01000010 DEFB %01100010 DEFB %01010010 DEFB %01001010 DEFB %01000110 DEFB %01000010 DEFB %00000000 ; $34 - Character: 'O' CHR$(52) DEFB %00000000 DEFB %00111100 DEFB %01000010 DEFB %01000010 DEFB %01000010 DEFB %01000010 DEFB %00111100 DEFB %00000000 ; $35 - Character: 'P' CHR$(53) DEFB %00000000 DEFB %01111100 DEFB %01000010 DEFB %01000010 DEFB %01111100 DEFB %01000000 DEFB %01000000 DEFB %00000000 ; $36 - Character: 'Q' CHR$(54) DEFB %00000000 DEFB %00111100 DEFB %01000010 DEFB %01000010 DEFB %01010010 DEFB %01001010 DEFB %00111100 DEFB %00000000 ; $37 - Character: 'R' CHR$(55) DEFB %00000000 DEFB %01111100 DEFB %01000010 DEFB %01000010 DEFB %01111100 DEFB %01000100 DEFB %01000010 DEFB %00000000 ; $38 - Character: 'S' CHR$(56) DEFB %00000000 DEFB %00111100 DEFB %01000000 DEFB %00111100 DEFB %00000010 DEFB %01000010 DEFB %00111100 DEFB %00000000 ; $39 - Character: 'T' CHR$(57) DEFB %00000000 DEFB %11111110 DEFB %00010000 DEFB %00010000 DEFB %00010000 DEFB %00010000 DEFB %00010000 DEFB %00000000 ; $3A - Character: 'U' CHR$(58) DEFB %00000000 DEFB %01000010 DEFB %01000010 DEFB %01000010 DEFB %01000010 DEFB %01000010 DEFB %00111100 DEFB %00000000 ; $3B - Character: 'V' CHR$(59) DEFB %00000000 DEFB %01000010 DEFB %01000010 DEFB %01000010 DEFB %01000010 DEFB %00100100 DEFB %00011000 DEFB %00000000 ; $3C - Character: 'W' CHR$(60) DEFB %00000000 DEFB %01000010 DEFB %01000010 DEFB %01000010 DEFB %01000010 DEFB %01011010 DEFB %00100100 DEFB %00000000 ; $3D - Character: 'X' CHR$(61) DEFB %00000000 DEFB %01000010 DEFB %00100100 DEFB %00011000 DEFB %00011000 DEFB %00100100 DEFB %01000010 DEFB %00000000 ; $3E - Character: 'Y' CHR$(62) DEFB %00000000 DEFB %10000010 DEFB %01000100 DEFB %00101000 DEFB %00010000 DEFB %00010000 DEFB %00010000 DEFB %00000000 ; $3F - Character: 'Z' CHR$(63) DEFB %00000000 DEFB %01111110 DEFB %00000100 DEFB %00001000 DEFB %00010000 DEFB %00100000 DEFB %01111110 DEFB %00000000 ; .END ;TASM assembler instruction. ; ; This marks the end of the ZX81 ROM. ; ; As a bonus feature, I will now include the code for ; the G007 graphics board and ; the ZX81 monitor ; ; The 8K space divides into four 2K spaces like so: ; ; 2000 RAM (1K or 2K) remapped ; 2800 G007 ROM ; 3000 ; 3800 ZX81 Monitor ; ; The G007 uses some RAM ; 2300 G007 RAM variables ; ; 2000 #code $2000,$0800 ; RAM_2K ; 2300 ; xxxx data 4 ; reserves 4 bytes from the #data segment for variable "Toto" #code $2800,$0800 #if 0 ; ; just copy bytes. Provides a reference for comparing code output. ; ; G007 Graphics ; Start = 2800H ; End = 2FFFH mark_2800: DEFB $2A, $23, $23, $3A, $25, $23, $67, $EB mark_2808: DEFB $3A, $18, $23, $3D, $92, $57, $3E, $07 mark_2810: DEFB $A3, $6F, $26, $2D, $7E, $2A, $08, $23 mark_2818: DEFB $4A, $06, $00, $09, $09, $CB, $3A, $CB mark_2820: DEFB $1B, $CB, $3A, $CB, $1B, $CB, $3A, $CB mark_2828: DEFB $1B, $19, $47, $C9, $3A, $21, $23, $2A mark_2830: DEFB $27, $23, $ED, $5B, $23, $23, $D9, $2A mark_2838: DEFB $25, $23, $ED, $5B, $29, $23, $CB, $77 mark_2840: DEFB $28, $1C, $CB, $7F, $C0, $3A, $21, $40 mark_2848: DEFB $F5, $06, $08, $0F, $FD, $CB, $21, $16 mark_2850: DEFB $10, $F9, $EB, $D9, $EB, $D9, $CD, $5E mark_2858: DEFB $28, $F1, $32, $21, $40, $C9, $01, $DE mark_2860: DEFB $FF, $3A, $18, $23, $3D, $93, $ED, $52 mark_2868: DEFB $F2, $76, $28, $01, $22, $00, $7B, $D5 mark_2870: DEFB $19, $EB, $B7, $ED, $52, $D1, $E5, $63 mark_2878: DEFB $5F, $D9, $01, $FB, $28, $7D, $D9, $6F mark_2880: DEFB $D9, $B7, $ED, $52, $F2, $90, $28, $01 mark_2888: DEFB $04, $29, $2F, $19, $EB, $B7, $ED, $52 mark_2890: DEFB $ED, $43, $1A, $23, $D1, $B7, $ED, $52 mark_2898: DEFB $19, $30, $09, $EB, $01, $F6, $28, $D9 mark_28A0: DEFB $53, $5F, $7A, $D9, $ED, $43, $1C, $23 mark_28A8: DEFB $D9, $57, $D5, $D9, $C1, $3A, $21, $23 mark_28B0: DEFB $FE, $40, $30, $02, $45, $4B, $04, $0C mark_28B8: DEFB $CB, $3C, $38, $02, $28, $08, $CB, $1D mark_28C0: DEFB $CB, $3A, $CB, $1B, $18, $F2, $55, $CB mark_28C8: DEFB $3D, $D9, $C5, $CD, $07, $28, $D1, $3A mark_28D0: DEFB $1F, $23, $4F, $FD, $CB, $21, $06, $38 mark_28D8: DEFB $08, $3A, $1E, $23, $AE, $B1, $A0, $AE mark_28E0: DEFB $77, $D9, $7D, $05, $C8, $93, $30, $0A mark_28E8: DEFB $0D, $C8, $82, $D9, $19, $D9, $2A, $1A mark_28F0: DEFB $23, $E9, $2A, $1C, $23, $E9, $6F, $D9 mark_28F8: DEFB $19, $18, $D8, $6F, $D9, $CB, $00, $30 mark_2900: DEFB $D2, $2B, $18, $CF, $6F, $D9, $CB, $08 mark_2908: DEFB $30, $C9, $23, $18, $C6, $2A, $A8, $0E mark_2910: DEFB $E9, $CD, $0D, $29, $38, $0E, $21, $00 mark_2918: DEFB $00, $28, $06, $ED, $42, $F8, $C8, $18 mark_2920: DEFB $03, $ED, $4A, $F0, $E1, $C9, $CD, $11 mark_2928: DEFB $29, $22, $25, $23, $CD, $11, $29, $E5 mark_2930: DEFB $CD, $02, $0C, $C1, $ED, $5B, $25, $23 mark_2938: DEFB $28, $0C, $3D, $C0, $21, $9C, $0C, $22 mark_2940: DEFB $30, $40, $43, $C3, $B2, $0B ; The Plot Routine: ; A == the plot number N ; BC == screen X ; DE == screen Y mark_2946: DEFB $B7, $28 mark_2948: DEFB $F9, $3D, $D5, $C5, $F5, $CD, $1F, $2E mark_2950: DEFB $F1, $D1, $C1, $FE, $81, $20, $0F, $ED mark_2958: DEFB $53, $30, $23, $ED, $43, $32, $23, $01 mark_2960: DEFB $00, $00, $50, $58, $3E, $0B, $CB, $57 mark_2968: DEFB $28, $09, $2A, $29, $23, $E5, $2A, $27 mark_2970: DEFB $23, $18, $07, $2A, $32, $23, $E5, $2A mark_2978: DEFB $30, $23, $B7, $ED, $5A, $D1, $E8, $22 mark_2980: DEFB $23, $23, $EB, $B7, $ED, $4A, $E8, $22 mark_2988: DEFB $25, $23, $5F, $3E, $C0, $A4, $E0, $3E mark_2990: DEFB $C0, $A2, $E0, $D9, $E5, $D5, $C5, $CD mark_2998: DEFB $9F, $29, $C1, $D1, $E1, $D9, $C9, $D9 mark_29A0: DEFB $7C, $B2, $37, $20, $05, $3A, $18, $23 mark_29A8: DEFB $3D, $BD, $3A, $21, $23, $1F, $32, $21 mark_29B0: DEFB $23, $7B, $CB, $7F, $28, $04, $2A, $10 mark_29B8: DEFB $23, $E9, $F5, $E6, $03, $1F, $3D, $2F mark_29C0: DEFB $67, $9F, $6F, $22, $1E, $23, $E5, $CB mark_29C8: DEFB $5B, $20, $28, $3A, $20, $23, $AB, $E6 mark_29D0: DEFB $FB, $28, $0F, $21, $34, $23, $7B, $07 mark_29D8: DEFB $07, $07, $E6, $03, $85, $6F, $7E, $32 mark_29E0: DEFB $21, $40, $CD, $2C, $28, $E1, $FD, $CB mark_29E8: DEFB $21, $0E, $38, $26, $7C, $A5, $28, $22 mark_29F0: DEFB $2C, $5D, $E5, $3A, $21, $23, $CB, $6B mark_29F8: DEFB $20, $3D, $CB, $73, $20, $3E, $E1, $CB mark_2A00: DEFB $7F, $20, $0F, $E5, $CD, $00, $28, $A6 mark_2A08: DEFB $32, $17, $23, $D1, $7E, $B2, $AB, $A0 mark_2A10: DEFB $AE, $77, $F1, $32, $20, $23, $21, $2A mark_2A18: DEFB $23, $11, $2E, $23, $01, $08, $00, $CB mark_2A20: DEFB $67, $28, $11, $3A, $21, $23, $E6, $C0 mark_2A28: DEFB $17, $30, $02, $CB, $F7, $32, $21, $23 mark_2A30: DEFB $2E, $26, $0E, $04, $ED, $B8, $C9, $21 mark_2A38: DEFB $FF, $FF, $18, $03, $2A, $0A, $23, $D9 mark_2A40: DEFB $E6, $E0, $C2, $AD, $0E, $21, $21, $23 mark_2A48: DEFB $FD, $36, $21, $55, $06, $03, $23, $23 mark_2A50: DEFB $5E, $23, $23, $56, $D5, $10, $F7, $C1 mark_2A58: DEFB $D1, $E1, $B7, $28, $02, $44, $4D, $78 mark_2A60: DEFB $BC, $30, $03, $C5, $E3, $C1, $7C, $BA mark_2A68: DEFB $30, $01, $EB, $7A, $D9, $E6, $07, $3C mark_2A70: DEFB $47, $7C, $CB, $05, $07, $07, $07, $10 mark_2A78: DEFB $F9, $67, $22, $38, $23, $D9, $7C, $B8 mark_2A80: DEFB $3E, $07, $30, $03, $C5, $E3, $C1, $EB mark_2A88: DEFB $F5, $79, $D9, $67, $6F, $4F, $22, $1A mark_2A90: DEFB $23, $06, $FE, $D9, $93, $D9, $30, $04 mark_2A98: DEFB $06, $00, $ED, $44, $57, $D9, $7A, $90 mark_2AA0: DEFB $D9, $67, $BA, $30, $02, $EB, $04, $6C mark_2AA8: DEFB $2C, $5C, $CB, $3B, $F1, $0F, $30, $09 mark_2AB0: DEFB $E5, $D5, $C5, $0F, $D9, $38, $CD, $18 mark_2AB8: DEFB $CE, $D9, $60, $2E, $01, $C1, $D1, $E3 mark_2AC0: DEFB $2D, $20, $16, $2A, $1A, $23, $79, $BC mark_2AC8: DEFB $38, $01, $67, $BD, $30, $01, $6F, $22 mark_2AD0: DEFB $1A, $23, $E1, $2D, $28, $E7, $E5, $18 mark_2AD8: DEFB $15, $7B, $92, $38, $0A, $5F, $CB, $40 mark_2AE0: DEFB $28, $0C, $79, $80, $4F, $18, $D9, $84 mark_2AE8: DEFB $5F, $3E, $01, $B0, $81, $4F, $79, $D9 mark_2AF0: DEFB $FD, $CB, $21, $0E, $38, $CA, $E3, $D5 mark_2AF8: DEFB $C5, $E5, $ED, $5B, $1A, $23, $47, $B9 mark_2B00: DEFB $30, $02, $41, $4F, $ED, $43, $1A, $23 mark_2B08: DEFB $79, $BB, $3C, $38, $01, $7B, $6F, $7A mark_2B10: DEFB $B8, $30, $02, $78, $3D, $95, $3C, $F5 mark_2B18: DEFB $CD, $07, $28, $F1, $4F, $EB, $21, $39 mark_2B20: DEFB $23, $7E, $07, $07, $07, $77, $2B, $CB mark_2B28: DEFB $06, $B6, $2A, $1E, $23, $AD, $2F, $6F mark_2B30: DEFB $EB, $7B, $AE, $B2, $A0, $AE, $77, $0D mark_2B38: DEFB $20, $14, $E1, $24, $CB, $7D, $28, $94 mark_2B40: DEFB $E1, $E1, $E1, $E1, $7C, $A5, $CA, $12 mark_2B48: DEFB $2A, $2C, $E5, $C3, $45, $2A, $CB, $18 mark_2B50: DEFB $30, $DF, $23, $41, $79, $E6, $07, $4F mark_2B58: DEFB $CB, $38, $CB, $38, $CB, $38, $28, $08 mark_2B60: DEFB $7B, $AE, $B2, $AE, $77, $23, $10, $F8 mark_2B68: DEFB $37, $0C, $18, $CB, $2A, $13, $23, $2D mark_2B70: DEFB $B5, $C2, $09, $08, $25, $C2, $B8, $23 mark_2B78: DEFB $3A, $21, $23, $17, $D8, $00, $00, $2A mark_2B80: DEFB $28, $23, $3A, $27, $23, $CB, $72, $20 mark_2B88: DEFB $05, $6F, $C6, $08, $30, $0D, $7C, $D6 mark_2B90: DEFB $08, $30, $04, $3A, $18, $23, $3D, $32 mark_2B98: DEFB $29, $23, $AF, $32, $27, $23, $CB, $72 mark_2BA0: DEFB $C0, $CD, $EF, $2E, $7D, $FE, $F9, $38 mark_2BA8: DEFB $02, $1E, $02, $2F, $E6, $07, $3C, $57 mark_2BB0: DEFB $7C, $3C, $D9, $57, $D9, $D5, $CD, $07 mark_2BB8: DEFB $28, $D9, $79, $AE, $D9, $EB, $C1, $C5 mark_2BC0: DEFB $6F, $26, $00, $29, $10, $FD, $EB, $06 mark_2BC8: DEFB $02, $3A, $7B, $40, $AE, $FD, $B6, $7C mark_2BD0: DEFB $A2, $AE, $0D, $28, $01, $77, $53, $23 mark_2BD8: DEFB $10, $EF, $0E, $20, $09, $D9, $23, $15 mark_2BE0: DEFB $28, $02, $10, $D6, $E1, $C3, $9A, $29 mark_2BE8: DEFB $ED, $57, $0F, $30, $08, $AF, $32, $22 mark_2BF0: DEFB $40, $3C, $32, $13, $23, $CD, $CF, $0A mark_2BF8: DEFB $AF, $32, $13, $23, $FD, $36, $22, $02 mark_2C00: DEFB $4F, $C9, $CD, $A0, $0C, $DA, $AD, $0E mark_2C08: DEFB $0E, $01, $C8, $0E, $FF, $C9, $FD, $46 mark_2C10: DEFB $22, $0E, $21, $CD, $18, $09, $CD, $9B mark_2C18: DEFB $09, $7E, $12, $FD, $34, $3A, $2A, $0C mark_2C20: DEFB $40, $23, $54, $5D, $ED, $B1, $C3, $5D mark_2C28: DEFB $0A, $8B, $8D, $2D, $7F, $81, $49, $75 mark_2C30: DEFB $5F, $40, $42, $2B, $17, $1F, $37, $52 mark_2C38: DEFB $45, $0F, $6D, $2B, $44, $2D, $5A, $3B mark_2C40: DEFB $4C, $45, $0D, $52, $54, $4D, $15, $6A mark_2C48: DEFB $01, $14, $02, $06, $00, $81, $0E, $06 mark_2C50: DEFB $DE, $05, $AB, $0D, $06, $00, $B5, $0E mark_2C58: DEFB $00, $DC, $0C, $00, $D8, $0E, $04, $14 mark_2C60: DEFB $06, $DF, $06, $05, $B9, $0D, $04, $00 mark_2C68: DEFB $2E, $0E, $05, $E8, $2B, $01, $00, $E9 mark_2C70: DEFB $0E, $05, $A7, $2E, $05, $6A, $0D, $00 mark_2C78: DEFB $C3, $03, $03, $AF, $0E, $03, $30, $07 mark_2C80: DEFB $06, $1A, $06, $00, $92, $0E, $03, $6C mark_2C88: DEFB $0E, $05, $40, $03, $05, $4D, $2F, $00 mark_2C90: DEFB $7C, $0E, $00, $B2, $0E, $03, $4E, $2E mark_2C98: DEFB $06, $1A, $06, $1A, $06, $00, $26, $29 mark_2CA0: DEFB $2A, $A8, $0E, $E9, $00, $0E, $0C, $06 mark_2CA8: DEFB $00, $AE, $2E, $03, $B2, $2E, $03, $B6 mark_2CB0: DEFB $2E, $03, $53, $2F, $05, $CB, $0A, $03 mark_2CB8: DEFB $2C, $07, $FD, $36, $01, $01, $CD, $73 mark_2CC0: DEFB $0A, $CD, $95, $0A, $21, $00, $40, $36 mark_2CC8: DEFB $FF, $21, $2D, $40, $CB, $6E, $28, $0E mark_2CD0: DEFB $FE, $E3, $7E, $C2, $6F, $0D, $CD, $A6 mark_2CD8: DEFB $0D, $C8, $CF, $0C, $CF, $08, $DF, $06 mark_2CE0: DEFB $00, $FE, $76, $C8, $4F, $E7, $79, $D6 mark_2CE8: DEFB $E1, $38, $3B, $4F, $21, $29, $0C, $09 mark_2CF0: DEFB $4E, $09, $18, $03, $2A, $30, $40, $7E mark_2CF8: DEFB $23, $22, $30, $40, $01, $F4, $0C, $C5 ; ; bits shifting right within a byte: ; mark_2D00: DEFB $80, $40, $20, $10, $08, $04, $02, $01 ; mark_2D08: DEFB $CD, $F7, $2B, $C3, $07, $02, $32, $28 mark_2D10: DEFB $40, $EB, $21, $0A, $00, $39, $7E, $3C mark_2D18: DEFB $E6, $F0, $D6, $D0, $4F, $23, $7E, $D6 mark_2D20: DEFB $04, $B1, $4F, $3A, $3B, $40, $07, $9F mark_2D28: DEFB $A1, $20, $10, $2A, $10, $40, $01, $DF mark_2D30: DEFB $FF, $09, $CB, $FC, $22, $04, $23, $3E mark_2D38: DEFB $01, $18, $0E, $2A, $0C, $40, $ED, $4B mark_2D40: DEFB $00, $23, $09, $CB, $FC, $22, $06, $23 mark_2D48: DEFB $AF, $32, $19, $23, $2B, $7E, $EB, $C9 mark_2D50: DEFB $3A, $19, $23, $3D, $C2, $73, $2D, $3E mark_2D58: DEFB $1E, $ED, $47, $ED, $6A, $2A, $04, $23 mark_2D60: DEFB $01, $08, $01, $3E, $FE, $CD, $B5, $02 mark_2D68: DEFB $3E, $1F, $ED, $47, $3A, $28, $40, $D6 mark_2D70: DEFB $08, $18, $04, $2B, $3A, $28, $40, $4F mark_2D78: DEFB $DD, $E1, $FD, $CB, $3B, $7E, $C2, $9D mark_2D80: DEFB $02, $3E, $FE, $06, $01, $21, $9A, $2D mark_2D88: DEFB $CD, $95, $2D, $29, $00, $5F, $2A, $06 mark_2D90: DEFB $23, $CB, $FC, $DD, $E9, $ED, $4F, $3E mark_2D98: DEFB $DD, $FB, $76, $21, $00, $22, $3E, $24 mark_2DA0: DEFB $36, $01, $35, $28, $02, $CF, $1A, $23 mark_2DA8: DEFB $BC, $20, $F5, $65, $11, $00, $20, $01 mark_2DB0: DEFB $00, $01, $ED, $B0, $24, $14, $04, $ED mark_2DB8: DEFB $B0, $21, $F1, $07, $11, $A0, $23, $01 mark_2DC0: DEFB $60, $00, $ED, $B0, $16, $20, $21, $B4 mark_2DC8: DEFB $2F, $46, $18, $04, $5E, $23, $7E, $12 mark_2DD0: DEFB $23, $10, $F9, $14, $CB, $52, $28, $F1 mark_2DD8: DEFB $C9 ; Delete Display File: mark_2DD9: DEFB $CD, $E7, $02, $21, $87, $3E, $CD mark_2DE0: DEFB $D8, $09, $C0, $EB, $2A, $29, $40, $CB mark_2DE8: DEFB $76, $28, $04, $ED, $53, $29, $40, $2A mark_2DF0: DEFB $0C, $40, $C3, $5D, $0A, $CD, $D9, $2D mark_2DF8: DEFB $01, $92, $19, $2A, $0C, $40, $2B, $CD mark_2E00: DEFB $9E, $09, $3E, $76, $12, $13, $12, $23 mark_2E08: DEFB $23, $36, $3E, $23, $36, $87, $23, $36 mark_2E10: DEFB $8D, $23, $36, $19, $23, $77, $23, $77 mark_2E18: DEFB $CD, $07, $02, $3E, $01, $18, $37 ; Check & Set Up Display File: mark_2E1F: DEFB $2A mark_2E20: DEFB $65, $22, $11, $D9, $BF, $19, $3A, $64 mark_2E28: DEFB $22, $D6, $21, $B4, $B5, $C4, $9B, $2D mark_2E30: DEFB $2A, $0C, $40, $3E, $76, $2B, $2B, $BE mark_2E38: DEFB $C4, $F5, $2D, $2A, $0C, $40, $ED, $5B mark_2E40: DEFB $00, $23, $19, $22, $06, $23, $11, $09 mark_2E48: DEFB $00, $19, $22, $08, $23, $C9, $CD, $02 mark_2E50: DEFB $0C, $C0 ; Clear The Screen: mark_2E52: DEFB $3D, $FA, $2A, $0A, $F5, $CD mark_2E58: DEFB $1F, $2E, $F1, $FE, $02, $ED, $4B, $18 mark_2E60: DEFB $23, $2A, $0C, $40, $30, $30, $3D, $23 mark_2E68: DEFB $22, $0E, $40, $2B, $2B, $2B, $1E, $00 mark_2E70: DEFB $06, $10, $2B, $73, $2B, $73, $2B, $77 mark_2E78: DEFB $2B, $77, $10, $FA, $0D, $20, $F1, $06 mark_2E80: DEFB $09, $3E, $01, $2B, $73, $10, $FC, $21 mark_2E88: DEFB $34, $23, $06, $14, $3D, $28, $F4, $21 mark_2E90: DEFB $21, $18, $22, $39, $40, $C9, $C0, $2B mark_2E98: DEFB $2B, $06, $20, $2B, $2B, $2B, $7E, $2F mark_2EA0: DEFB $77, $10, $FA, $0D, $20, $F3, $C9, $2A mark_2EA8: DEFB $96, $0A, $3E, $4D, $18, $35, $3E, $DD mark_2EB0: DEFB $18, $2E, $3E, $D6, $18, $02, $3E, $CE mark_2EB8: DEFB $F5, $CD, $02, $0C, $06, $1E, $3D, $FE mark_2EC0: DEFB $06, $30, $19, $CB, $3F, $67, $28, $02 mark_2EC8: DEFB $3E, $01, $F5, $9F, $6F, $CB, $8C, $25 mark_2ED0: DEFB $22, $7B, $40, $CD, $1F, $2E, $06, $1F mark_2ED8: DEFB $F1, $32, $14, $23, $78, $ED, $47, $F1 mark_2EE0: DEFB $2A, $71, $0D, $85, $6F, $E9, $57, $3A mark_2EE8: DEFB $39, $40, $E6, $80, $C3, $6C, $2B, $7A mark_2EF0: DEFB $D1, $D9, $E5, $D5, $C5, $2A, $0C, $23 mark_2EF8: DEFB $87, $30, $0B, $2A, $0E, $23, $CB, $77 mark_2F00: DEFB $28, $04, $2A, $15, $23, $3F, $EB, $6F mark_2F08: DEFB $26, $00, $9F, $4F, $3A, $7B, $40, $2F mark_2F10: DEFB $FD, $A6, $7C, $A9, $4F, $29, $29, $19 mark_2F18: DEFB $06, $08, $D9, $D5, $C9, $FD, $35, $39 mark_2F20: DEFB $3E, $18, $90, $47, $87, $87, $87, $6F mark_2F28: DEFB $3A, $18, $23, $95, $D8, $3E, $21, $91 mark_2F30: DEFB $4F, $26, $00, $29, $09, $ED, $4B, $08 mark_2F38: DEFB $23, $09, $CD, $EF, $2E, $01, $22, $00 mark_2F40: DEFB $D9, $79, $AE, $D9, $77, $09, $D9, $23 mark_2F48: DEFB $10, $F7, $C3, $9A, $29, $CD, $D9, $2D mark_2F50: DEFB $C3, $F6, $02, $CD, $02, $0C, $C0, $3D mark_2F58: DEFB $FA, $69, $08, $CD, $1F, $2E, $CD, $E7 mark_2F60: DEFB $02, $3A, $18, $23, $47, $2A, $08, $23 mark_2F68: DEFB $AF, $5F, $D3, $FB, $3E, $7F, $DB, $FE mark_2F70: DEFB $0F, $D2, $86, $08, $DB, $FB, $87, $FA mark_2F78: DEFB $AD, $2F, $30, $F0, $0E, $20, $C5, $4E mark_2F80: DEFB $06, $08, $CB, $01, $1F, $B3, $57, $DB mark_2F88: DEFB $FB, $1F, $30, $FB, $7A, $D3, $FB, $10 mark_2F90: DEFB $F1, $23, $C1, $0D, $20, $E8, $23, $23 mark_2F98: DEFB $3E, $03, $B8, $38, $02, $5F, $1D, $DB mark_2FA0: DEFB $FB, $1F, $30, $FB, $7B, $D3, $FB, $10 mark_2FA8: DEFB $C3, $3E, $04, $D3, $FB, $C3, $07, $02 mark_2FB0: DEFB $FB, $10, $C3, $3E, $0A, $12, $A0, $13 mark_2FB8: DEFB $23, $15, $A4, $16, $23, $40, $C1, $60 mark_2FC0: DEFB $08, $61, $2D, $75, $06, $76, $23, $01 mark_2FC8: DEFB $0A, $54, $02, $85, $C1, $7F, $73, $80 mark_2FD0: DEFB $2D, $8D, $50, $8E, $2D, $E3, $C3, $E4 mark_2FD8: DEFB $0E, $E5, $2D, $13, $00, $75, $01, $E6 mark_2FE0: DEFB $0A, $55, $0D, $1E, $0F, $1E, $16, $20 mark_2FE8: DEFB $10, $07, $11, $08, $18, $C0, $35, $EE mark_2FF0: DEFB $36, $55, $37, $C6, $AD, $E6, $AE, $2E mark_2FF8: DEFB $F2, $C3, $F3, $1D, $F4, $2F, $ED, $00 ; #else ; G007 source code, reverse engineered. ; ; The ZX81 labels will have been generated already. ; No need to include ZX definitions: ; ;=============================== ; G007 Hi-Res graphics board for the ZX81 ; ; Source code partially reverse-engineered. ; A work in progress... ; ; 2011-05-15 Assembles to create correct ROM image. ; ; Verifed by comparing the hex files, ; the known-good reference generated by ; 2048 defb statements containing the original bytes. ; ; The source code below is not guaranteed to create the ROM image ; exactly the way the original author had in mind, ; as I'm not him and I don't have the original source code. ; ; This file was created from a disassembly generated by the ; impressive VB81 emulator program. ; ; It was already know that the G007 switched out pages of ; the ZX81 BASIC ROM and patched in replacements from ; the G007 ROM and the ZX81's internal 1K (or 2K) RAM. ; This is a thrifty use of RAM that expansion RAM packs ; usually just disabled. ; ; Memory map: ; ; 0000-0FFF ; 2000-23FF 1K RAM inside ZX81, remapped here. ; 2400-27FF 1K RAM more RAM if ZX81 has a 2K RAM chip ; 2800-2FFF 2K G007 ; 3000-3FFF Empty ; 4000-7FFF External RAM pack ; ; Patching: ; ; 2C00-2CFF (ROM) also appears at 0C00-0CFF ; 2000-20FF (RAM) also appears at 0000-00FF ; 2200-22FF (RAM) also appears at 0200-02FF ; ; The ROM patching is active all the time. ; The RAM patching is active only in hi-res mode. ; ; The patches didn't cover every modification needed, ; so one routine is copied from ROM to RAM and ; then individual bytes are modified there ; by the initialisation routine which also ; initialises some variables. ; ; Graphics routines: ; ; These have not yet been analysed. ; Bresenham's algorithm will be there is some form. ; ; Triangle-filling is a sophisticated feature, ; using 8-bit maths for a practical speed. ; ; Future enhancements ; ; Programmers may like to try writing faster routines, ; or adding more commands now that memory is cheap. ; ; The bit-mask array at $2D00 looks like this: ; 10000000 ; 01000000 ; 00100000 ; 00010000 ; 00001000 ; 00000100 ; 00000010 ; 00000001 ; ; and suggests that pixels ; may be plotted one at a time. ; When I wrote a triangle-filling algorithm for the Atom, ; I made frequent use of horizontal lines. ; I optimised these by working out the partially-filled ; bytes at the left and right sides, and writing ; whole bytes (of 8 pixels) between the partial bytes. ; This used two overlapping tables like so: ; ; 10000000 ; BIT_MASK_R ; 11000000 ; 11100000 ; 11110000 ; 11111000 ; 11111100 ; 11111110 ; 11111111 ; BIT_MASK_L ; 01111111 ; 00111111 ; 00011111 ; 00001111 ; 00000111 ; 00000011 ; 00000001 ; ; This technique might be able to increase the triangle filling speed. ; ; A proper ellipse algorithm would also be welcome, ; not one of those approximations using polygons! ; ;=============================== ; Assembly was done by a very handy online tool: ; http://k1.dyndns.org/cgi-bin/zasm.cgi ; which avoids the chore of installing it ; on one's own machine. ; The online tool is limited to one source file and ; one include file, but that's not a big deal ; for a tiny 2K ROM like this one. ; ;=============================== ; Problems ; The G007 ROM had several instances of opcdoes ; beginning with FD CB ; involving the Y register. ; VB81 disassembled them into statements ; that looked mangled and would not re-assemble. ; So I've just added them with defb statements. ; ; ;=============================== ; Global constants: ;=============================== FALSE equ 0 NOT_G007 equ FALSE ;=============================== ; ZX81 constants: ;=============================== ; ZX characters (not the same as ASCII) ;------------------------------- ZX_EQU equ $14 ZX_COMMA equ $1A ZX_THEN equ $DE ZX_TO equ $DF ZX_INV_K equ $B0 ZX_NEWLINE equ $76 HRG_BYTES_PER_LINE equ 34 ALL_BITS_SET equ -1 ;------------------------------- ; tokens ;------------------------------- _CLASS_00 equ 0 _CLASS_01 equ 1 _CLASS_02 equ 2 _CLASS_03 equ 3 _CLASS_04 equ 4 _CLASS_05 equ 5 _CLASS_06 equ 6 ;=============================== ; ZX81 I/O locations: ;=============================== IO_PORT_KEYBOARD_RD equ $FE ; A0 low ZX_NMI_GEN equ $FD ; A1 low ZX_PRINTER_PORT equ $FB ; A2 low ;=============================== ; ZX81 RAM variables ;=============================== RAMBASE equ $4000 ERR_NR equ $4000 FLAGS equ $4001 ERR_SP equ $4002 RAMTOP equ $4004 MODE equ $4006 PPC equ $4007 VERSN equ $4009 E_PPC equ $400A D_FILE equ $400C DF_CC equ $400E VARS equ $4010 DEST equ $4012 E_LINE equ $4014 CH_ADD equ $4016 X_PTR equ $4018 STKBOT equ $401A STKEND equ $401C BERG equ $401E MEM equ $401F UNUSED_8 equ $4021 G007_FLAG_Y equ UNUSED_8 ; DF_SZ equ $4022 S_TOP equ $4023 LAST_K equ $4025 DEBOUNCE equ $4027 MARGIN equ $4028 NXTLIN equ $4029 NXT_LINE equ $4029 OLDPPC equ $402B FLAGX equ $402D STRLEN equ $402E T_ADDR equ $4030 SEED equ $4032 FRAMES equ $4034 COORDS equ $4036 PR_CC equ $4038 S_POSN equ $4039 S_POSN_hi equ S_POSN+1 CDFLAG equ $403B PRBUFF equ $403C MEMBOT equ $407B PROGRAM equ $407D UNUSED_16 equ $407B UNUSED_16_hi equ UNUSED_16+1 G007_RESTART equ UNUSED_16 ; First byte after system variables: USER_RAM equ $407D MAX_RAM equ $7FFF ;=============================== ; ZX BASIC ROM addresses ;=============================== ; restart constants START equ $0000 ; = 0 ERROR_1 equ $0008 ; = 8 PRINT_A equ $0010 ; = 16 GET_CHAR equ $0018 ; = 24 TEST_SP equ $001C ; = 28 NEXT_CH equ $0020 ; = 32 FP_CALC equ $0028 ; = 40 ;------------------------------- L0108 equ $0108 SLOW_FAST equ $0207 ; DISPLAY_5 equ $02B5 ; L029D equ $029D ; Inside the 'LOC_ADDR' subroutine SET_FAST equ $02E7 LOAD equ $0340 LIST equ $0730 COPY equ $0869 SAVE equ $02F6 NEW equ $03C3 LLIST equ $072C PRINT_CH equ $07F1 ; old, replaced L0809 equ $0809 LOC_ADDR equ $0918 ONE_SPACE equ $099B MAKE_ROOM equ $099E LINE_ADDR equ $09D8 E_LINE_NO equ $0A73 L0A95 equ $0A95 ; []*BIOS ROM*. Part way into 088A COPY_CONT PRINT equ $0ACF CLS equ $0A2A RECLAIM_1 equ $0A5D LPRINT equ $0ACB PRINT equ $0ACF PLOT_UNPLOT equ $0BAF L0BB2 equ $0BB2 ; STK_TO_A equ $0C02 SCROLL equ $0C0E ;------------------------------- ; Parameter table addresses: ; Checked in ROM disassembly book: ;------------------------------- P_LET equ $0C48 P_GOTO equ $0C4B P_IF equ $0C4F P_GOSUB equ $0C54 P_STOP equ $0C58 P_RETURN equ $0C5B P_FOR equ $0C5E P_NEXT equ $0C66 P_PRINT equ $0C6A P_INPUT equ $0C6D P_DIM equ $0C71 P_REM equ $0C74 P_NEW equ $0C77 P_RUN equ $0C7A P_LIST equ $0C7D P_POKE equ $0C80 P_RAND equ $0C86 P_LOAD equ $0C89 P_SAVE equ $0C8C P_CONT equ $0C8F P_CLEAR equ $0C92 P_CLS equ $0C95 P_PLOT equ $0C98 ; redefined in G007 patch P_UNPLOT equ $0C9E ; redefined in G007 patch P_SCROLL equ $0CA4 P_PAUSE equ $0CA7 ;P_SLOW equ $0CAB ;P_FAST equ $0CAE ;P_COPY equ $0CB1 ;P_LPRINT equ $0CB4 ;P_LLIST equ $0CB7 ;------------------------------- STOP equ $0CDC ; defined in this file REM equ $0D6A INPUT_RE equ $0D6F REPORT_C equ $0D9A ; according to the book REPORT_C_007 equ $0D26 ; seems the right one SYNTAX_Z equ $0DA6 IF equ $0DAB FOR equ $0DB9 NEXT equ $0E2E RAND equ $0E6C CONT equ $0E7C GOTO equ $0E81 POKE equ $0E92 L0EA8 equ $0EA8 ; Inside the 'FIND_INT.' subroutine REPORT_B equ $0EAD ; check this!!! RUN equ $0EAF CLEAR_007 equ $0EB2 ; goes to JP CLEAR GOSUB equ $0EB5 RETURN equ $0ED8 INPUT equ $0EE9 FAST equ $0F23 SLOW equ $0F2B PAUSE equ $0F32 DIM equ $1409 CLEAR equ $149A SET_MEM equ $14BC ;=============================== ; G007 Memory patch addresses ;=============================== ; These patches only appear in hi-res mode ; RAM_PATCH_0000 equ $0000 RAM_PATCH_0200 equ $0200 ROM_PATCH_0C00 equ $0C00 ; ; Their aliases are always present: ; RAM_PATCH_2000 equ $2000 RAM_PATCH_2200 equ $2200 ;=============================== ; G007 Plot number notes (a work in prgress) ;=============================== ; N-1 ; ; 76543 210 ; ..... .00 Line in white. ; ..... .01 Line black. ; ..... .10 Line inverting. ; ..... .11 Line inverting, omit last pixel. ; ; ..... 0.. Absolute co-ordinates ; ..... 1.. Relative co-ordinates ; ; ....0 ... Line ; ....1 ... Single pixel ; ; .0100 ... Coarse dotted line ; .0101 ... Add 40: triangle, plain ; .1001.... Add 72: triangle, textured (not available in invert mode) ; .1000 ... Add 64: fine dotted line ; .1100 ... Add 96: chain dotted line ; ; Note that PLOT 12 and PLOT 16 miss out the pixel, so simply move the PLOT position. ; ;=============================== ; G007 Byte constants ;=============================== G007_INT_REG_VALUE_FOR_HI_RES_GRAPHICS equ $1F G007_INT_REG_VALUE_FOR_LO_RES_GRAPHICS equ $1E ; Dec. Hex. Bytes System Variables: G007 ; 8448 2100 Reserved for user defined characters ; 8703 21FF ; ; 8704 2200 Another page, possibly ; 8959 22FF ;=============================== ; G007 Byte constants ;=============================== MEM_PATCH_SIZE equ $0100 ;=============================== ; G007 RAM variables ;=============================== V2265 equ $2265 V2264 equ $2264 ; Dec. Hex. Bytes System Variables: G007 ; 8960 2300 2 Offset of hi-res display file, less 9, from the D-FILE variable ; 8962 2302 2 Not used ; 8964 2304 2 Start address of last line of lo-res display file G007_DISPLAY_OFFSET_FROM_DFILE_LESS_9 equ $2300 ; conflict! G007_UNUSED_2302 equ $2302 G007_DISPLAY_ADDRESS_LO_RES_LAST_LINE equ $2304 G007_DISPLAY_ADDRESS_LESS_9 equ $2306 ; 8966 2306 2 Start address of hi-res display file, less 9 (used for video) G007_DISPLAY_ADDRESS equ $2308 ; 8968 2308 2 Start address of hi-res display file G007_TRIANGLE_TEXTURE equ $230A ; 8970 230A 2 Bytes defining triangle texture G007_CHAR_TABLE_ADDR_0_63 equ $230C ; 8972 230C 2 Character table address for CHR$0-63 G007_CHAR_TABLE_ADDR_128_159 equ $230E ; 8974 230E 2 Character table address for CHR$128-159 G007_PLOT_ROUTINES_VECTOR equ $2310 ; 8976 2310 2 Vector for additional plot routines G007_FLAG_0 equ $2312 ; 8978 2312 3 * Various flags G007_FLAG_1 equ $2313 G007_FLAG_2 equ $2314 G007_USR_DEF_CHR_TAB_LESS_256 equ $2315 ; 8981 2315 2 Address of user-defined character table, less 256 G007_READ_POINT_BYTE equ $2317 ; 8983 2317 1 Read-point byte. Non-zero if pixel is set. G007_DISPLAY_HEIGHT equ $2318 ; 8984 2318 1 * Display height, normally 192 G007_FLAG_3 equ $2319 ; 8985 2319 1 Flags ;G007_TEMP_WORD_0 equ $231C ; G007_TEMP_BYTE_0 equ $231A ; 9886 231A 7 Temporary variables for PLOT routine. G007_TEMP_BYTE_1 equ $231B G007_TEMP_WORD_1 equ $231C ; ;G007_TEMP_BYTE_2 equ $231C ;G007_TEMP_BYTE_3 equ $231D G007_TEMP_WORD_2 equ $231E ; G007_TEMP_BYTE_4 equ $231E G007_TEMP_BYTE_5 equ $231F G007_TEMP_BYTE_6 equ $2320 G007_OUT_OF_RANGE_FLAGS equ $2321 ; 8993 2321 1 Plot out of range flags. Bit 7 = latest statement G007_UNUSED equ $2322 ; 8994 2322 1 Not used G007_PLOT_X equ $2323 ; 8995 2323 2 X co-ordinate for PLOT. Signed 16-bit G007_PLOT_Y equ $2325 ; 8997 2325 2 Y co-ordinate for PLOT. Signed 16-bit G007_PLOT_X_PREVIOUS_N1 equ $2327 ; 8999 2327 8 X and Y co-ordinates for previous two statements G007_PLOT_Y_PREVIOUS_N1 equ $2329 G007_PLOT_X_PREVIOUS_N2 equ $232B G007_PLOT_Y_PREVIOUS_N2 equ $232D G007_FLAG_4 equ $232F ; 9007 232F 1 Flags G007_ORIGIN_Y equ $2330 ; 9008 2330 2 Y co-ordinate of graphics origin G007_ORIGIN_X equ $2332 ; 9010 2332 2 X co-ordinate of graphics origin G007_LINE_TYPE equ $2334 ; 9012 2334 4 Bytes defining four line types G007_TEMP_BYTE_7 equ $2338 ; 9016 2338 2 Temporary variable for PLOT G007_TEMP_BYTE_8 equ $2339 ; G007_V23A0 equ $23A0 ;=============================== ; G007 RAM routines ;=============================== ; Yes, there is such a thing! L23B8 equ $23B8 ;=============================== ; G007 ROM routines ;=============================== L2BF7 equ $2BF7 ; invalid opcode address SLOW_FAST_007 equ $2D08 ; new! ;=============================== ; Needed by zasm: #target rom ; declare target file format #code $2800,$0800 ; declare code segment start and size ; ;=============================== ; G007 ROM assembly code ;=============================== ; Start of ROM contents; ; 10240/12287 : 2800/2FFF ;=============================== G007_GET_PIXEL_ADDRESS_AND_MASK: ; LD HL,(G007_PLOT_X) ; X co-ordinate for PLOT. Signed 16-bit. Fetch 16 bits L2803: LD A,(G007_PLOT_Y) ; Y co-ordinate for PLOT. Signed 16-bit. Fetch 8 bits LD H,A ; and store in H L2807: EX DE,HL ; then swap it into D LD A,(G007_DISPLAY_HEIGHT) DEC A; SUB D ; LD D,A LD A,7 ; A must be 0 to 7 AND A,E ; E is the LS byte of the X co-ordinate LD L,A ; L = A = selects bit-mask LD H,$2D ; bit-mask array is at $2D00 LD A,(HL) ; get byte with bit set at appropriate position LD HL,(G007_DISPLAY_ADDRESS) ; Start address of hi-res display file ;------------------------------- ; Add two bytes for every line ; LD C,D ; BC = Y coordinate LD B,0 ADD HL,BC ; HL += BC*2 ADD HL,BC ;------------------------------- ; DE /= 8 gets byte offset from left of screen ; SRL D ; shift DE right RR E SRL D ; shift DE right RR E SRL D ; shift DE right RR E ADD HL,DE ; HL = G007_DISPLAY_ADDRESS + byte offset of XY-co-ordinates LD B,A ; A and B hold the bitmask RET ; return ;=============================== L282C: LD A,(G007_OUT_OF_RANGE_FLAGS) ; Plot out of range flags. Bit 7 = latest statement LD HL,(G007_PLOT_X_PREVIOUS_N1) LD DE,(G007_PLOT_X) ; X co-ordinate for PLOT. Signed 16-bit EXX LD HL,(G007_PLOT_Y) LD DE,(G007_PLOT_Y_PREVIOUS_N1) ; test two most recent out-of-range flag bits: BIT 6,A JR Z,L285E BIT 7,A RET NZ LD A,(G007_FLAG_Y); PUSH AF LD B,8 ;------------------------------- loop_284B: RRCA ;284C FD;CB;21;16 LD C,SLA (IY+CH_ADD-RAMBASE) output from VB81 disassembler #if 1 RL (IY+G007_FLAG_Y-RAMBASE) ; makes FD CB 21 16 - correct! #else ; force bytes defb $FD defb $CB defb $21 defb $16 #endif DJNZ loop_284B ;------------------------------- EX DE,HL EXX EX DE,HL EXX CALL L285E POP AF LD (G007_FLAG_Y),A; RET ;=============================== L285E: LD BC,-HRG_BYTES_PER_LINE ; NB negative number = $FFDE LD A,(G007_DISPLAY_HEIGHT) DEC A SUB E SBC HL,DE JP P,L2876 ;------------------------------- LD BC,HRG_BYTES_PER_LINE LD A,E PUSH DE ADD HL,DE EX DE,HL OR A,A SBC HL,DE POP DE ;------------------------------- L2876: PUSH HL LD H,E LD E,A EXX LD BC,L28FB LD A,L EXX LD L,A EXX OR A,A SBC HL,DE JP P,L2890 ; [10384] ;------------------------------- LD BC,L2904 CPL ADD HL,DE EX DE,HL OR A,A SBC HL,DE L2890: LD (G007_TEMP_BYTE_0),BC ; Temporary variables for PLOT routine. POP DE OR A,A SBC HL,DE ADD HL,DE JR NC,L28A4 ;------------------------------- EX DE,HL LD BC,L28F6 EXX LD D,E LD E,A LD A,D EXX L28A4: LD (G007_TEMP_WORD_1),BC EXX LD D,A ;------------------------------- PUSH DE EXX POP BC ;------------------------------- LD A,(G007_OUT_OF_RANGE_FLAGS) ; Plot out of range flags. Bit 7 = latest statement CP $40 JR NC,L28B6 ;------------------------------- LD B,L ; BC = LE LD C,E ;------------------------------- L28B6: INC B INC C ;------------------------------- L28B8: SRL H JR C,L28BE JR Z,L28C6 ;------------------------------- L28BE: RR L SRL D RR E JR L28B8 ;------------------------------- L28C6: LD D,L SRL L EXX PUSH BC CALL L2807 POP DE LD A,(G007_TEMP_BYTE_5) LD C,A ;------------------------------- L28D3: ; Bytes from disassembler: ;28D3 FD;CB;21;06 LD C,SLA (IY+6) #if 1 RLC (IY+G007_FLAG_Y-RAMBASE) ; makes FD CB 21 06 #else ; force bytes defb $FD defb $CB defb $21 defb $06 #endif JR C,L28E1 ;------------------------------- LD A,(G007_TEMP_BYTE_4) XOR A,(HL) OR A,C AND A,B XOR A,(HL) LD (HL),A ;------------------------------- L28E1: EXX LD A,L DEC B RET Z ;------------------------------- SUB E JR NC,L28F2 ;------------------------------- DEC C RET Z ;------------------------------- ADD A,D EXX ADD HL,DE EXX LD HL,(G007_TEMP_BYTE_0) ; Temporary variables for PLOT routine. JP (HL) ;------------------------------- L28F2: LD HL,(G007_TEMP_WORD_1) JP (HL) ;------------------------------- L28F6: LD L,A EXX ADD HL,DE JR L28D3 ;------------------------------- L28FB: LD L,A EXX RLC B JR NC,L28D3 ;------------------------------- DEC HL JR L28D3 ;------------------------------- L2904: LD L,A EXX RRC B JR NC,L28D3 ;------------------------------- INC HL JR L28D3 ;------------------------------- G007_INTEGER_FROM_STACK_TO_BC: LD HL,(L0EA8) ; Inside the 'FIND_INT.' subroutine ; 0EA7 FIND_INT CALL 158A,FP_TO_BC ; so 0EA8 should contain $158A, pointing to the FP_TO_BC routine JP (HL) ; exit ;=============================== G007_INTEGER_FROM_STACK_TO_HL: CALL G007_INTEGER_FROM_STACK_TO_BC ; get an integer JR C,L2924 ;------------------------------- LD HL,0 JR Z,L2921 ;------------------------------- SBC HL,BC ; HL = 0 - BC RET M RET Z ;------------------------------- JR L2924 ;------------------------------- L2921: ADC HL,BC RET P ;------------------------------- L2924: POP HL RET ;=============================== ; G007_PLOT_UNPLOT_N_X_Y: ; takes parameters from the stack ; CALL G007_INTEGER_FROM_STACK_TO_HL ; get Y LD (G007_PLOT_Y),HL CALL G007_INTEGER_FROM_STACK_TO_HL ; get X PUSH HL CALL STK_TO_A ; get N ; POP BC ; BC = X LD DE,(G007_PLOT_Y) ; DE = Y JR Z,G007_PLOT ; DEC A ; if (N-1) is zero RET NZ ;------------------------------- LD HL,L0C9C ; then T_ADDR = HL = L0C9C LD (T_ADDR),HL ; ;------------------------------- L2942: LD B,E JP L0BB2 ; []*BIOS ROM* ;=============================== ; The Plot Routine: ; A == the plot number N ; BC == screen X ; DE == screen Y ;------------------------------- G007_PLOT: OR A,A JR Z,L2942 ;------------------------------- DEC A ; when PLOT N value is decremented, bits make more sense ;------------------------------- PUSH DE ; push screen Y PUSH BC ; push screen X PUSH AF ; push plot number-1 CALL G007_CHECK_AND_SET_UP_DISPLAY_FILE POP AF POP DE POP BC ; NB BC and DE are swapped ;------------------------------- CP $81 ; Was A=129 (PLOT 130 sets graphics origin) JR NZ,G007_PLOT_XY_TO_HISTORY ;------------------------------- G007_ORIGIN_SET: ; LD (G007_ORIGIN_Y),DE ; Y co-ordinate of graphics origin LD (G007_ORIGIN_X),BC ; X co-ordinate of graphics origin LD BC,$0000 ; BC = 0 LD D,B ; DE = BC = 0 LD E,B LD A,$0B ;------------------------------- G007_PLOT_XY_TO_HISTORY: ; BIT 2,A; ; the (PLOT_N -1) JR Z,G007_PLOT_ABSOLUTE ;------------------------------- G007_PLOT_RELATIVE: ; LD HL,(G007_PLOT_Y_PREVIOUS_N1) PUSH HL LD HL,(G007_PLOT_X_PREVIOUS_N1) JR G007_PLOT_ABSOLUTE_OR_RELATIVE ;=============================== G007_PLOT_ABSOLUTE: LD HL,(G007_ORIGIN_X) ; X co-ordinate of graphics origin PUSH HL LD HL,(G007_ORIGIN_Y) ; Y co-ordinate of graphics origin ;------------------------------- ; ; G007_PLOT_ABSOLUTE_OR_RELATIVE: ; OR A,A ; update flags ADC HL,DE ; HL = G007_PLOT_Y + G007_ORIGIN_Y POP DE ; DE = G007_PLOT_X co-ordinate of graphics origin RET PE ;------------------------------- LD (G007_PLOT_X),HL ; record plot X EX DE,HL OR A,A ; restore Flags ADC HL,BC ; HL = G007_PLOT_X + G007_ORIGIN_X RET PE ;------------------------------- LD (G007_PLOT_Y),HL ; record plot Y LD E,A LD A,%11000000 ; $C0 AND A,H ; RET PO; ;------------------------------- LD A,%11000000 ; $C0 AND A,D RET PO ;------------------------------- ; push alternate HL,DE,BC EXX PUSH HL PUSH DE PUSH BC CALL G007_RANGE_CHECK ;------------------------------- ; pop alternate BC,DE,HL L299A: POP BC POP DE POP HL EXX RET ;=============================== G007_RANGE_CHECK: EXX LD A,H ; A = H OR D OR A,D SCF JR NZ,G007_RANGE_CHECK_UPDATE ; if not zero, out of range already so ignore display height ;------------------------------- LD A,(G007_DISPLAY_HEIGHT) ; check Y coordinate DEC A ; if (G007_DISPLAY_HEIGHT - Y ) is less than zero, CP L ; set the Carry flag ;------------------------------- G007_RANGE_CHECK_UPDATE: ; latest flag in Carry is shifted into history flags LD A,(G007_OUT_OF_RANGE_FLAGS) ; RRA ; shift bits right. Bit 7 = latest statement LD (G007_OUT_OF_RANGE_FLAGS),A ; LD A,E ; E bit 7 BIT 7,A JR Z,L29BA ;------------------------------- ; gets here if PLOT_N is over 130 LD HL,(G007_PLOT_ROUTINES_VECTOR) ; Vector for additional plot routines JP (HL) ; This looks very promising, ; makes it easy to bolt-on extra graphics routines ;=============================== L29BA: PUSH AF AND 3 RRA DEC A CPL LD H,A SBC A,A LD L,A LD (G007_TEMP_WORD_2),HL PUSH HL BIT 3,E JR NZ,L29F3 ;------------------------------- LD A,(G007_TEMP_BYTE_6) XOR A,E AND %11111011 ; $FB. Bit 2 ignored JR Z,L29E2 ;------------------------------- LD HL,G007_LINE_TYPE LD A,E ;------------------------------- ; A *= 8 RLCA RLCA RLCA ;------------------------------- AND $03 ADD A,L LD L,A LD A,(HL) LD (G007_FLAG_Y),A; ;------------------------------- L29E2: CALL L282C; POP HL ;------------------------------- ; Bytes from disassembler: 29E6 FD;CB;21;0E LD C,SLA (IY+14) RRC (IY+G007_FLAG_Y-RAMBASE) ; makes FD CB 21 0E JR C,L2A12 ;=============================== LD A,H ; A = H and L AND A,L JR Z,L2A12 ;------------------------------- INC L LD E,L PUSH HL ;------------------------------- L29F3: LD A,(G007_OUT_OF_RANGE_FLAGS) ; Bit 7 = latest statement BIT 5,E JR NZ,G007_TRIANGLE_PLAIN ;------------------------------- BIT 6,E JR NZ,G007_TRIANGLE_TEXTURED ;------------------------------- POP HL BIT 7,A JR NZ,L2A12 ;------------------------------- PUSH HL CALL G007_GET_PIXEL_ADDRESS_AND_MASK AND A,(HL) LD (G007_READ_POINT_BYTE),A ; "Read-point" byte. Non-zero if pixel is set. POP DE LD A,(HL) OR A,D XOR A,E AND A,B XOR A,(HL) LD (HL),A ;------------------------------- L2A12: POP AF LD (G007_TEMP_BYTE_6),A LD HL,G007_PLOT_Y_PREVIOUS_N1+1 LD DE,G007_PLOT_Y_PREVIOUS_N2+1 LD BC,8 BIT 4,A JR Z,L2A34 ;------------------------------- LD A,(G007_OUT_OF_RANGE_FLAGS) ; Plot out of range flags. Bit 7 = latest statement AND $C0 ; only want most recent two bits RLA JR NC,L2A2D SET 6,A ; carry flag into bit 6 of A ;------------------------------- L2A2D: LD (G007_OUT_OF_RANGE_FLAGS),A LD L,$26 LD C,4 ;------------------------------- L2A34: LDDR ; (DE--)=(HL--); BC-- UNTIL BC IS ZERO RET ;=============================== G007_TRIANGLE_PLAIN: LD HL,ALL_BITS_SET JR G007_TRIANGLE_TEXTURED_BY_HL ;=============================== G007_TRIANGLE_TEXTURED: LD HL,(G007_TRIANGLE_TEXTURE) ; Bytes defining triangle texture ;------------------------------- G007_TRIANGLE_TEXTURED_BY_HL: EXX AND $E0 ; = 224 JP NZ,REPORT_B; ;------------------------------- L2A45: LD HL,G007_OUT_OF_RANGE_FLAGS LD (IY+G007_FLAG_Y-RAMBASE),$55 LD B,3 ;------------------------------- loop_2A4E: INC HL ; HL+=2 INC HL LD E,(HL) INC HL ; HL+=2 INC HL LD D,(HL) PUSH DE DJNZ loop_2A4E ; BC-- ;------------------------------- POP BC ; restore register pairs POP DE POP HL ;------------------------------- OR A,A JR Z,L2A5F ;------------------------------- LD B,H ; BC=HL LD C,L ;------------------------------- L2A5F: LD A,B CP H JR NC,L2A66 ;------------------------------- PUSH BC EX (SP),HL POP BC ;------------------------------- L2A66: LD A,H CP D JR NC,L2A6B ;------------------------------- EX DE,HL ;------------------------------- L2A6B: LD A,D EXX AND 7 INC A LD B,A LD A,H ;------------------------------- loop_2A72: RLC L ; L *= 2 ;------------------------------- RLCA ; A *= 8 RLCA RLCA ;------------------------------- DJNZ loop_2A72 ; loop while BC-- is not zero ;------------------------------- LD H,A LD (G007_TEMP_BYTE_7),HL ; Temporary variable for PLOT EXX ;------------------------------- LD A,H CP B LD A,7 JR NC,L2A87 ;------------------------------- loop_2A84: PUSH BC EX (SP),HL POP BC ;------------------------------- L2A87: EX DE,HL PUSH AF LD A,C EXX LD H,A LD L,A LD C,A LD (G007_TEMP_BYTE_0),HL ; Temporary variables for PLOT routine. LD B,$FE EXX SUB E EXX ;------------------------------- JR NC,skip_2A9C LD B,$00 NEG skip_2A9C: ;------------------------------- LD D,A EXX LD A,D SUB B EXX LD H,A ;------------------------------- CP D JR NC,skip_2AA7 EX DE,HL INC B skip_2AA7: ;------------------------------- LD L,H INC L LD E,H SRL E POP AF RRCA JR NC,L2AB9 ;------------------------------- PUSH HL ;------------------------------- PUSH DE PUSH BC ;------------------------------- RRCA EXX ;------------------------------- JR C,loop_2A84 JR L2A87 ;=============================== L2AB9: EXX LD H,B LD L,1 ;------------------------------- loop_2ABD: POP BC POP DE ;------------------------------- EX (SP),HL ;------------------------------- L2AC0: DEC L JR NZ,L2AD9 ;------------------------------- LD HL,(G007_TEMP_BYTE_0) ; Temporary variables for PLOT routine. LD A,C ;------------------------------- CP H JR C,skip_2ACB LD H,A skip_2ACB: ;------------------------------- CP L JR NC,skip_2ACF LD L,A skip_2ACF: ;------------------------------- LD (G007_TEMP_BYTE_0),HL ; Temporary variables for PLOT routine. POP HL DEC L ;------------------------------- L2AD4: JR Z,loop_2ABD PUSH HL JR L2AEE ;------------------------------- L2AD9: LD A,E SUB D JR C,L2AE7 ;------------------------------- LD E,A BIT 0,B JR Z,L2AEE ;------------------------------- LD A,C ADD A,B LD C,A JR L2AC0 ;------------------------------- L2AE7: ADD A,H LD E,A LD A,1 OR A,B ADD A,C LD C,A ;------------------------------- L2AEE: LD A,C EXX ;------------------------------- RRC (IY+G007_FLAG_Y-RAMBASE) ; makes FD CB 21 0E JR C,L2AC0 ; if ;------------------------------- EX (SP),HL ;------------------------------- PUSH DE PUSH BC PUSH HL ;------------------------------- LD DE,(G007_TEMP_BYTE_0) LD B,A ;------------------------------- CP C JR NC,skip_2B04 LD B,C LD C,A skip_2B04: ;------------------------------- LD (G007_TEMP_BYTE_0),BC LD A,C ;------------------------------- CP E INC A JR C,skip_2B0E LD A,E skip_2B0E: ;------------------------------- LD L,A LD A,D ;------------------------------- CP B JR NC,skip_2B15 LD A,B DEC A skip_2B15: ;------------------------------- SUB L INC A PUSH AF CALL L2807 POP AF LD C,A EX DE,HL LD HL,G007_TEMP_BYTE_8 LD A,(HL) ;------------------------------- RLCA RLCA RLCA ;------------------------------- LD (HL),A DEC HL RLC (HL) OR A,(HL) LD HL,(G007_TEMP_WORD_2) XOR A,L CPL LD L,A EX DE,HL ;------------------------------- loop_2B31: LD A,E XOR A,(HL) OR A,D AND A,B XOR A,(HL) LD (HL),A ;------------------------------- loop_2B37: DEC C JR NZ,L2B4E ;------------------------------- POP HL INC H BIT 7,L JR Z,L2AD4 ;------------------------------- ; discard 3 words from stack POP HL POP HL POP HL ;------------------------------- POP HL LD A,H AND A,L JP Z,L2A12 ;------------------------------- INC L PUSH HL JP L2A45 ;------------------------------- L2B4E: RR B JR NC,loop_2B31 ;------------------------------- INC HL LD B,C LD A,C AND $07 LD C,A ;------------------------------- SRL B ; B *= 8 SRL B SRL B ;------------------------------- JR Z,L2B68 ;------------------------------- loop_2B60: LD A,E XOR A,(HL) OR A,D XOR A,(HL) LD (HL),A INC HL DJNZ loop_2B60 ;------------------------------- L2B68: SCF INC C JR loop_2B37 ;------------------------------- L2B6C: LD HL,(G007_FLAG_1) DEC L OR A,L JP NZ,L0809 ; iii) Testing S-POSN: 0808 ENTER-CH LD D,A ; G007 skips that first instruction though. ;------------------------------- DEC H ; if --H, JP NZ,L23B8 ; then jump to modified copy of a ZX81 routine, in RAM. ;------------------------------- ; LD A,(G007_OUT_OF_RANGE_FLAGS) ; Plot out of range flags. Bit 7 = latest statement RLA RET C ;------------------------------- NOP NOP LD HL,(G007_PLOT_X_PREVIOUS_N1+1) LD A, (G007_PLOT_X_PREVIOUS_N1) BIT 6,D ;------------------------------- mark_2B87: JR NZ,L2B8E ; 20;05 LD L,A ADD A,8 JR NC,L2B9B ;------------------------------- L2B8E: LD A,H ;------------------------------- SUB 8 JR NC,skip_2B97 LD A,(G007_DISPLAY_HEIGHT) DEC A skip_2B97: ;------------------------------- LD (G007_PLOT_Y_PREVIOUS_N1),A; XOR A,A ; A = 0 ;------------------------------- L2B9B: LD (G007_PLOT_X_PREVIOUS_N1),A BIT 6,D RET NZ ;------------------------------- CALL L2EEF LD A,L ;------------------------------- CP $F9 JR C,skip_2BAB LD E,2 skip_2BAB: ;------------------------------- CPL AND 7 INC A LD D,A LD A,H INC A EXX LD D,A EXX PUSH DE CALL L2807 EXX ;------------------------------- L2BBA: LD A,C XOR A,(HL) EXX EX DE,HL LXXX: POP BC PUSH BC LD L,A LD H,$00 ;------------------------------- loop_2BC3: ADD HL,HL DJNZ loop_2BC3 ;------------------------------- EX DE,HL LD B,2 ;------------------------------- L2BC9: LD A,(G007_RESTART); XOR A,(HL) OR A,(IY+G007_RESTART+1-RAMBASE) AND A,D XOR A,(HL) ;------------------------------- DEC C JR Z,skip_2BD6 LD (HL),A skip_2BD6: ;------------------------------- LD D,E INC HL DJNZ L2BC9 ;------------------------------- LD C,$20 ADD HL,BC EXX INC HL ;------------------------------- DEC D JR Z,skip_2BE4 ;------------------------------- DJNZ L2BBA ;------------------------------- skip_2BE4: ;------------------------------- POP HL JP L299A ;=============================== PRINT_007: LD A,I ; read graphics mode RRCA ;------------------------------- JR NC,skip_2BF5 XOR A,A ; A = 0 LD (DF_SZ),A ; SET DF_SZ INC A LD (G007_FLAG_1),A skip_2BF5: ;------------------------------- CALL PRINT ; [PRINT] XOR A,A ; A = 0 LD (G007_FLAG_1),A LD (IY+DF_SZ-RAMBASE),2 ; The lines above have no return or jump statements ; They will fall into copy of the end of the STK_TO_BC routine ; Perhaps a cunning trick to save two bytes? :-) ;=============================== ;=============================== ;=============================== org ROM_PATCH_0C00 ; ; 256-byte block patched in to ZX81 BASIC at 0C00 hex ; This cleverly alters the language syntax, ; adding parameters and/or pointing to new routines. ; LD C,A ; from the end of the STK_TO_BC routine RET ;=============================== ; THE 'STK_TO_A' SUBROUTINE (duplicated for the paged ROM) ; This subroutine 'loads' the A register with the floating point number held at the top of the calculator stack. The number must be in the range 00-FF. ;------------------------------- STK_TO_A: #if NOT_G007 ; CALL 15CD,FP_TO_A ; This is what the disassembly book says #else CALL L0CA0 ; new in G007 #endif JP C,REPORT_B ;------------------------------- LD C,$01 RET Z LD C,$FF RET ;=============================== ; THE 'SCROLL' COMMAND ROUTINE (duplicated for the paged ROM) ; The first part of the routine sets the correct values of DF_CC and S_POSN to allow for the next printing to occur at the start of the bottom line + 1. ; Next the end address of the first line in the display file is identified and the whole of the display file moved to overwrite this line. ;------------------------------- SCROLL: mark_0C0E: LD B,(IY+DF_SZ-RAMBASE) ; ??? Disassembly book says LD B,(DF_SZ) LD C,CHARS_HORIZONTAL + 1 ;change here, $21 originally CALL LOC_ADDR CALL ONE_SPACE LD A,(HL) LD (DE),A INC (IY+S_POSN_hi-RAMBASE) ; LD HL,(D_FILE); INC HL LD D,H LD E,L CPIR JP RECLAIM_1 ;=============================== ; ; THE SYNTAX TABLES ; ; i) The offset table ; ; There is an offset value for each of the BASIC commands and by ; adding this offset to the value of the address where it is found, ; the correct address for the command in the parameter table is ; obtained. ; 2C29: 8B 8D 2D 7F 81 49 75 mark_0C29: offset_t: ; expression address byte offset expected defb P_LPRINT-$ ; 0CB4 $8B defb P_LLIST-$ ; 0CB1 ; $8D ; defb P_STOP-$ ; 0C58 ; $2D ; defb P_SLOW-$ ; 0CAB ; $7F ; defb P_FAST-$ ; 0CAE ; $81 ; defb P_NEW-$ ; 0C77 ; $49 ; defb P_SCROLL_007-$ ; 0CA4 ; $75 ; ; 2C30: 5F 40 42 2B 17 1F 37 52 defb P_CONT-$ ; 0CBF ; $5F ; defb P_DIM-$ ; 0C71 ; $40 ; defb P_REM-$ ; 0C74 ; $42 ; defb P_FOR-$ ; 0C5E ; $2B ; defb P_GOTO-$ ; 0C4B ; $17 ; defb P_GOSUB-$ ; 0C54 ; $1F ; defb P_INPUT-$ ; 0C6D ; $37 ; defb P_LOAD-$ ; 0C89 ; $52 ; ; 2C38: 45 0F 6D 2B 44 2D 5A 3B defb P_LIST-$ ; 0C7D ; $45 ; defb P_LET-$ ; 0C48 ; $0F ; defb P_PAUSE-$ ; 0CA7 ; $6D ; defb P_NEXT-$ ; 0C66 ; $2B ; defb P_POKE-$ ; 0C80 ; $44 ; defb P_PRINT-$ ; 0C6A ; $2D ; Same as normal ZX81 defb P_PLOT_007-$ ; 0C98 ; $5A ; defb P_RUN-$ ; 0C7A ; $3B ; ; 2C40: 4C 45 0D 52 54 4D 15 6A defb P_SAVE-$ ; 0C8C ; $4C ; defb P_RAND-$ ; 0C86 ; $45 ; defb P_IF-$ ; 0C4F ; $0D ; defb P_CLS-$ ; 0C95 ; $52 ; defb P_UNPLOT_007-$ ; 0C98 ; $54 ; This byte is 5A, an offset to 0C9E, in normal ZX81 ; NB same address as PLOT defb P_CLEAR-$ ; 0C92 ; $4D ; defb P_RETURN-$ ; 0C5B ; $15 ; defb P_COPY-$ ; 0CB1 ; $6A ; ; ; ii) The parameter table. ; ; For each of the BASIC commands there are between 3 and 8 ; entries in the parameter table. The command classes for each of ; the commands are given, together with the required separators and ; these are followed by the address of the appropriate routine. ; 2C48: 01 14 02 mark_0C48: P_LET: defb _CLASS_01 ; A variable is required. defb ZX_EQU ; Separator: '=' defb _CLASS_02 ; An expression, numeric or string, ; must follow. ; 244B: 06 00 81 0E 06 P_GOTO: mark_0C4B: defb _CLASS_06 ; A numeric expression must follow. defb _CLASS_00 ; No further operands. defw GOTO P_IF: mark_0C4F: defb _CLASS_06 ; A numeric expression must follow. mark_0C50 ; 2C50: DE 05 AB 0D defb ZX_THEN ; Separator: 'THEN' defb _CLASS_05 ; Variable syntax checked entirely ; by routine. defw IF P_GOSUB: ; mark_0C54: defb _CLASS_06 ; A numeric expression must follow. defb _CLASS_00 ; No further operands. defw GOSUB ; 0EB5 ; 2C58: 00 DC 0C P_STOP: ; mark_0C58: ; 2C54: 06 00 B5 0E defb _CLASS_00 ; No further operands. defw STOP ; 2c5B: 00 D8 0E P_RETURN defb _CLASS_00 ; No further operands. defw RETURN ; 2c5e: 04 14 P_FOR: #if 0 mark_0C5E: #else #endif defb _CLASS_04 ; A single character variable must ; follow. defb ZX_EQU ; Separator: '=' defb _CLASS_06 ; A numeric expression must follow. defb ZX_TO ; Separator: 'TO' defb _CLASS_06 ; A numeric expression must follow. defb _CLASS_05 ; Variable syntax checked entirely ; by routine. defw FOR ; 0C66: 04 00 2E 0E P_NEXT: ; at $0C66: defb _CLASS_04 ; A single character variable must follow. defb _CLASS_00 ; No further operands. defw NEXT ; 2C6A: 05 E8 2B P_PRINT: mark_0C6A: defb _CLASS_05 ; Variable syntax checked entirely ; by routine. #if NOT_G007 defw PRINT ; This is the original routine #else defw PRINT_007 ; 2BE8 This is the new routine! #endif ; ; 2C6D: 01 00 E9 0E mark_0C6D: P_INPUT: defb _CLASS_01 ; A variable is required. defb _CLASS_00 ; No further operands. defw INPUT P_DIM: mark_0C71: defb _CLASS_05 ; Variable syntax checked entirely ; by routine. #if NOT_G007 defw DIM ; 1409 Original ZX81 replaced by #else defw DIM_007 ; 2EA7 new routine #endif ; ; ; 2c74: 05 6A 0D ; mark_0C74: P_REM: defb _CLASS_05 ; Variable syntax checked entirely by routine. defw REM mark_0C77: P_NEW: defb _CLASS_00 ; No further operands. defw NEW P_RUN: mark_0C7A: P_RUN: defb _CLASS_03 ; A numeric expression may follow ; else default to zero. defw RUN P_LIST: #if 0 mark_0C7D: #else #endif defb _CLASS_03 ; A numeric expression may follow ; else default to zero. defw LIST P_POKE: ; mark_0C80: defb _CLASS_06 ; A numeric expression must follow. defb ZX_COMMA ; Separator: ',' defb _CLASS_06 ; A numeric expression must follow. defb _CLASS_00 ; No further operands. defw POKE P_RAND: ; mark_0C86: defb _CLASS_03 ; A numeric expression may follow ; else default to zero. defw RAND P_LOAD: ; mark_0C89: defb _CLASS_05 ; Variable syntax checked entirely ; by routine. defw LOAD P_SAVE: ; mark_0C8C: defb _CLASS_05 ; Variable syntax checked entirely ; by routine. #if NOT_G007 defw SAVE ; 02F6 original #else defw SAVE_007 ; 2F4D new! #endif ; P_CONT: #if 0 #else #endif mark_0C8F: defb _CLASS_00 ; No further operands. defw CONT ; 0E7C ; P_CLEAR: ; mark_0C92: defb _CLASS_00 #if NOT_G007 defw CLEAR ; 149A original #else defw CLEAR_007 ; 0EB2 new. this points outside the G007 ROM #endif P_CLS: ; mark_0C95: #if NOT_G007 defb _CLASS_00 ; No further operands. ;; defw CLS ; original #else defb _CLASS_03 ; A numeric expression may follow ; else default to zero. defw G007_CLS_N ; 2E4E new! #endif ; ; ; mark_0C98: #if NOT_G007 ; originally the ZX81 does this: P_PLOT: ; original: plot X,Y defb _CLASS_06 ; A numeric expression must follow. X defb ZX_COMMA ; Separator: ',' defb _CLASS_06 ; A numeric expression must follow. Y defb _CLASS_00 ; No further operands. defw PLOT_UNPLOT ; 0BAF P_UNPLOT: ; original: plot X,Y defb _CLASS_06 ; A numeric expression must follow. X defb ZX_COMMA ; Separator: ',' defb _CLASS_06 ; A numeric expression must follow. Y defb _CLASS_00 ; No further operands. defw PLOT_UNPLOT ; 0BAF ; These are identical, so they could overlap #else ; The G007 saves bytes by having these ; identical parameter table entries overlapping: ; 0C98 / 2C98: 06 1A 06 1A 06 00 26 29 P_PLOT_007: P_UNPLOT_007: ; new: plot N,X,Y defb _CLASS_06 ; A numeric expression must follow. N defb ZX_COMMA ; Separator: ',' defb _CLASS_06 ; A numeric expression must follow. X defb ZX_COMMA ; Separator: ',' L0C9C: defb _CLASS_06 ; A numeric expression must follow. Y defb _CLASS_00 ; No further operands. defw G007_PLOT_UNPLOT_N_X_Y ; 2926 new! ; ; by saving those bytes, can put a tiny routine here: L0CA0: LD HL,(L0EA8) ; Inside the 'FIND_INT.' subroutine JP (HL) #endif ; ; Now back to the table! ; P_SCROLL_007 mark_0CA4: defb _CLASS_00 defw SCROLL ; 0C0E P_PAUSE: defb _CLASS_06 defb _CLASS_00 #if NOT_G007 mark_0CA9: ; 2CA9: 0F 32 defw PAUSE ; 0F32 original #else mark_0CA9: ; 2CA9: AE 2E ; 0CA7 defw PAUSE_007 ; 2EAE new! #endif ; ; 2CAB: 03 B2 2E ; 0CAB P_SLOW: mark_0CAB: #if NOT_G007 defb _CLASS_00 ; No further operands. defw SLOW ; 2B 0F SLOW,0F2B original #else defb _CLASS_03 ; new! Extra parameter sets graphic mode defw SLOW_007 ; 2EB2 new! #endif P_FAST: mark_0CAE: #if NOT_G007 defb _CLASS_00 ; No further operands. defw FAST ; 23 0F FAST,0F23 original #else defb _CLASS_03 ; new! Extra parameter sets graphic mode defw FAST_007 ; 2EB6 new! #endif ; ; 2CB1: 03 53 2F ; ; 0CB1 P_COPY: #if NOT_G007 defb _CLASS_00 ; original defw COPY ; 0869 original #else defb _CLASS_03 ; new! Extra parameter sets graphic mode ;;; defw COPY_007 ; 2EB6 new but wrong ???! defw L2F53 ; what the disassembler said #endif mark_0CB4: P_LPRINT: defb _CLASS_05 defw LPRINT ; 0ACB ; ; ; 2CB7: 03 2C 07 ; 0CB7 P_LLIST: defb _CLASS_03 defw LLIST ; 072C ; ; ; the rest of this page is just a copy of the usual ZX81 code LINE_SCAN: L0CBA: ; 2CBA: FD 36 01 01 CD 73 ; 2CC0: 0A CD 95 0A 21 00 40 36 ; 2CC8: FF 21 2D 40 CB 6E 28 0E ; 2CD0: FE E3 7E C2 6F 0D CD A6 ; 2CD8: 0D C8 CF 0C CF 08 DF 06 ; 2CE0: 00 FE 76 C8 4F E7 79 D6 ; 2CE8: E1 38 3B 4F 21 29 0C 09 ; 2CF0: 4E 09 18 03 2A 30 40 7E ; 2CF8: 23 22 30 40 01 F4 0C C5 ; ; which is described as follows in the ZX81 disassembly book: ; ; THE 'LINE SCANNING' ROUTINE ; ; The BASIC interpreter scans each line for BASIC commands and as each one is found ; the appropriate command routine is followed. ; The different parts of the routine are: ;------------------------------- ; i) The LINE_SCAN entry point leads to the line number being checked for validity. LD (IY+FLAGS-RAMBASE),$01 ; FLAGS = 1 CALL E_LINE_NO ; ;------------------------------- ; ii) The LINE_RUN entry point is used when replying to an INPUT prompt ; and this fact has be identified. ;------------------------------- LINE_RUN #if NOT_G007 CALL SET_MEM ; at $14BC #else CALL L0A95 ; JP 14BC,SET_MEM then return ; why it does this I do not know - KH #endif LD HL,ERR_NR LD (HL),$FF LD HL,FLAGX BIT 5,(HL) JR Z,LINE_NULL ;------------------------------- ; iii) The INPUT reply is tested to see if STOP was entered. CP $E3 LD A,(HL) JP NZ,INPUT_RE CALL SYNTAX_Z RET Z ; iv) If appropriate, report D is given. RST ERROR_1 defb $0C ;------------------------------- ; THE 'STOP' COMMAND ROUTINE ; The only action is to give report 9. ;------------------------------- STOP RST ERROR_1 defb 8 ;------------------------------- ; v) A return is made if the line is 'null'. ;------------------------------- LINE_NULL: mark_0CDE: ; old software from disassembly book: RST GET_CHAR LD B,0 CP ZX_NEWLINE RET Z ; vi) The first character is tested so as to check that it is a command. LD C,A RST NEXT_CH LD A,C SUB $E1 #if NOT_G007 JR C,REPORT_C ; $0D9A as per the book #else JR C,REPORT_C_007 ; $0D26 in G007 systems #endif ;------------------------------- ; vii) The offset for the command is found from the offset table. LD C,A LD HL,offset_t ; $0C29 ADD HL,BC LD C,(HL) ADD HL,BC JR GET_PARAM ; viii) The parameters are fetched in turn by a loc that returns to 0CF4. ; The separators are identitied by the test against +0B. ;------------------------------- mark_0CF4: SCAN_LOOP: LD HL,(T_ADDR) GET_PARAM: LD A,(HL) INC HL LD (T_ADDR),HL LD BC,SCAN_LOOP PUSH BC ; ; there is more to this routine but the patch ends here ; ; end of patch ;------------------------------- org $2D00 ; bits shifting right within a byte: ; defb %10000000 ; $80 defb %01000000 ; $40 defb %00100000 ; $20 defb %00010000 ; $10 defb %00001000 ; $08 defb %00000100 ; $04 defb %00000010 ; $02 defb %00000001 ; $01 ;------------------------------- L2D08: SLOW_FAST_007: ; at $2D08 CALL L2BF7 ; ??? not a valid opcode address? JP SLOW_FAST ; old routine ;------------------------------- L2D0E: LD (MARGIN),A ; EX DE,HL LD HL,10 ADD HL,SP LD A,(HL) INC A AND $F0 SUB $D0 LD C,A INC HL LD A,(HL) SUB 4 OR A,C LD C,A LD A,(CDFLAG) ; RLCA SBC A,A AND A,C JR NZ,L2D3B ;------------------------------- LD HL,(VARS) ; LD BC,-(CHARS_HORIZONTAL+1) ; $FFDF ADD HL,BC SET 7,H LD (G007_DISPLAY_ADDRESS_LO_RES_LAST_LINE),HL LD A,1 JR L2D49 ;------------------------------- L2D3B: LD HL,(D_FILE) ; GET D_FILE LD BC,(G007_DISPLAY_OFFSET_FROM_DFILE_LESS_9) ADD HL,BC SET 7,H LD (G007_DISPLAY_ADDRESS_LESS_9),HL XOR A,A ; A = 0 ;------------------------------- L2D49: LD (G007_FLAG_3),A DEC HL LD A,(HL) EX DE,HL RET ;------------------------------- LD A,(G007_FLAG_3) DEC A JP NZ,L2D73 ; [11635] ;------------------------------- LD A,G007_INT_REG_VALUE_FOR_LO_RES_GRAPHICS LD I,A ; Interrupt register = 0x1E sets low res mode ADC HL,HL LD HL,(G007_DISPLAY_ADDRESS_LO_RES_LAST_LINE) LD BC,$0108 LD A,$FE CALL DISPLAY_5; LD A,G007_INT_REG_VALUE_FOR_HI_RES_GRAPHICS LD I,A ; Interrupt register = 0x1F sets high res mode LD A,(MARGIN) ; GET MARGIN SUB 8 JR L2D77 ;------------------------------- L2D73: DEC HL LD A,(MARGIN) ; GET MARGIN ;------------------------------- L2D77: LD C,A POP IX ;------------------------------- BIT 7,(IY+CDFLAG-RAMBASE) ; makes FD CB 3B 7E JP NZ,L029D ; []*BIOS ROM* ;------------------------------- ; This jumps into the middle of the DISPLAY_3, where it meets this code: ;029D 79 LD A,C ;029E ED;44 NEG ;02A0 3C INC A ;02A1 08 EX AF,AF' ;02A2 D3;FE OUT (IO_PORT_KEYBOARD_RD),A ; ZX81 NMI GENERATOR on, for SLOW mode ;02A4 E1 POP HL ; restore registers ;02A5 D1 POP DE ;02A6 C1 POP BC ;02A7 F1 POP AF ;02A8 C9 RET ;------------------------------- LD A,$FE LD B,$01 LD HL,HALT_AT_2D9A CALL LOAD_R_AND_WAIT_FOR_INT ADD HL,HL ; double HL NOP LD E,A LD HL,(G007_DISPLAY_ADDRESS_LESS_9) SET 7,H JP (IX) ;=============================== LOAD_R_AND_WAIT_FOR_INT ; mark_2D95 ; Sets up the refresh register and waits for an interrupt: LD R,A ; Refresh row counter := accumulator LD A,221 ; 221 = $DD EI ; Enable interrupts, then drop into HALT ;------------------------------- HALT_AT_2D9A: HALT ;=============================== ; Copy two pages of ZX81 BASIC ROM to RAM patch areas, ; then modify bytes as controlled by a table of offsets and values ; This uses less memory than two whole pages of ROM ; If the RAM patches are not changed thereafter, ; one might be able to use a 16K ROM to hold two different versions of the ZX81 BASIC space, ; one with the 'RAM' patch and one without. ; The RAM testing would have to be disabled, because the ROM would cause it to fail. ;------------------------------- #if NOT_G007 ZX81_COPY: #else G007_COPY: #endif ;------------------------------- ; First check RAM by loading 512 bytes RAM from $2200 to $23FF with value 1, ; and decrement them to zero to test they are working RAM ; LD HL,RAM_PATCH_2200 ; destination RAM patch 2 LD A,$24 ;------------------------------- mark_2DA0: G007_COPY_LOOP: LD (HL),1 ; try writing the value 1 to a byte in RAM patch 2 DEC (HL) ; try decrementing it to zero JR Z,G007_COPY_SKIP ; if result is zero, skip error code report ;------------------------------- RST $08 defb $1A ; RST8 Arg ; Error Code:'R' (ZX81 on-board 1K/2K RAM not found) ;------------------------------- G007_COPY_SKIP mark_2DA7: INC HL ; next address CP H ; has HL reached $2400 (yet? JR NZ,G007_COPY_LOOP ; no, repeat. ;------------------------------- ; HL is now $2400 ; Copy 256 bytes from BASIC ROM to RAM patch 1: LD H,L ; HL is now $0000 (data source is start of ZX81 BASIC ROM) LD DE,RAM_PATCH_2000 ; data destination LD BC,$0100 ; 256 bytes LDIR ; (HL) -> (DE) 256 times ;------------------------------- ; HL is now $0100 ; DE is now $2100 ; BC is now $0000 ;------------------------------- INC H ; HL is now $0200 INC D ; DE is now $2200 INC B ; BC is now $0100 LDIR ; copy another 256 bytes to RAM patch 2 ;------------------------------- LD HL,PRINT_CH ; src = the original ZX81 print character routine LD DE,G007_V23A0 ; dst = LD BC,$0060 ; 60hex = 96 bytes, so stops just before 0851 (the 'LPRINT_CH routine) LDIR ; move ; BC is now $0000 LD D,$20 ; DE is now $20?? LD HL,TABLE_ONE ; copy data from this table: LOOP_2DC9: LD B,(HL) ; BC is now $0A00 (seems way too many bytes) JR G007_TABLE_END_TEST ; branch to end-of-table test ;------------------------------- G007_TABLE_ONE_LOOP: LD E,(HL) ; Get the offset INC HL ; next byte is data LD A,(HL) ; Get the data byte LD (DE),A ; ($2000+offset) = data byte ;------------------------------- G007_TABLE_END_TEST: mark_2DD0: INC HL ; next offset DJNZ G007_TABLE_ONE_LOOP ; repeat until BC is zero ;------------------------------- INC D ; D becomes $21 BIT 2,D ; test bit 2 (has D incremented to $23 ?) JR Z,LOOP_2DC9 RET ;=============================== ; Delete Display File: ; G007_DELETE_DISPLAY_FILE: CALL SET_FAST; LD HL,$3E87 CALL LINE_ADDR; RET NZ ;------------------------------- EX DE,HL LD HL,(NXT_LINE) ; BIT 6,(HL) JR Z,L2DEF ;------------------------------- LD (NXT_LINE),DE ; ;------------------------------- L2DEF: LD HL,(D_FILE) ; JP RECLAIM_1 ; exit ;------------------------------- L2DF5: CALL G007_DELETE_DISPLAY_FILE LD BC,$1992 ; 6546 decimal = LD HL,(D_FILE) ; DEC HL CALL MAKE_ROOM LD A,ZX_NEWLINE LD (DE),A ; to DE INC DE LD (DE),A ; and DE+1 INC HL ; HL += 2 INC HL LD (HL),$3E ; (HL++) = $3E 'Y' INC HL LD (HL),$87 ; (HL++) = $87 INC HL LD (HL),$8D ; (HL++) = $8D INC HL LD (HL),$19 ; (HL++) = $19 ';' INC HL LD (HL),A ; (HL++) = ZX_NEWLINE INC HL LD (HL),A ; (HL++) = ZX_NEWLINE ;------------------------------- L2E18: CALL SLOW_FAST ; LD A,1 JR G007_CLS_HI_RES ;------------------------------- G007_CHECK_AND_SET_UP_DISPLAY_FILE: ; LD HL,(V2265) ; in the RAM page 2 area ! Usually $4027 LD DE,$BFD9 ; 3FD9 + 32K, or -16423 = 16K - 39 bytes ADD HL,DE LD A,(V2264) SUB CHARS_HORIZONTAL+1 ; bytes per screen line OR A,H OR A,L CALL NZ,G007_COPY LD HL,(D_FILE) ; GET D_FILE LD A,ZX_NEWLINE DEC HL DEC HL CP (HL) ; pointing to a HALT? CALL NZ,L2DF5 ; no, ; else yes LD HL,(D_FILE) ; GET D_FILE LD DE,(G007_DISPLAY_OFFSET_FROM_DFILE_LESS_9) ADD HL,DE LD (G007_DISPLAY_ADDRESS_LESS_9),HL LD DE,9 ; HL += 9 ADD HL,DE LD (G007_DISPLAY_ADDRESS),HL RET ;------------------------------- G007_CLS_N: ; CALL STK_TO_A RET NZ ; drop through if zero flag set ;------------------------------- ; Clear The Screen: ; G007_CLS_A: DEC A JP M,CLS ; if A was zero ;------------------------------- G007_CLS_HI_RES: PUSH AF CALL G007_CHECK_AND_SET_UP_DISPLAY_FILE POP AF ;------------------------------- CP 2 LD BC,(G007_DISPLAY_HEIGHT) LD HL,(D_FILE) JR NC,L2E96 ;------------------------------- DEC A INC HL LD (DF_CC),HL ; Addr. for PRINT AT position DEC HL DEC HL DEC HL LD E,0 ; E = 0 is byte to fill screen ;------------------------------- loop_2E70: LD B,16 ; 16 DEC HL LD (HL),E ; but writes 2 bytes for each loop DEC HL LD (HL),E ; perhaps to reduce loop overhead? ;------------------------------- loop_2E76: DEC HL LD (HL),A ; writes A twice over DEC HL LD (HL),A DJNZ loop_2E76 ;------------------------------- DEC C JR NZ,loop_2E70 ;------------------------------- ; C is now zero LD B,9 ; BC is now $0900 LD A,1 ;------------------------------- loop_2E83: DEC HL LD (HL),E ; (--HL) = E while --BC DJNZ loop_2E83 ;------------------------------- ; BC is now zero LD HL,G007_LINE_TYPE LD B,20 ; decimal 20 DEC A JR Z,loop_2E83 ;------------------------------- LD HL,256*CHARS_VERTICAL + CHARS_HORIZONTAL + 1 LD (S_POSN),HL ; SET S_POSN RET ;=============================== L2E96: RET NZ DEC HL ; HL -= 2 DEC HL ;------------------------------- outer loop loop_2E99: LD B,32 ; 32 bytes to invert DEC HL ; HL -= 2 DEC HL ; skips past 2 HALT characters ;------------------------------- inner loop loop_2E9D: DEC HL LD A,(HL) ; read CPL ; invert (one's complement) LD (HL),A ; write DJNZ loop_2E9D ;------------------------------- DEC C ; C is obviously the number of horizontal lines to invert JR NZ,loop_2E99 ;------------------------------- RET ;------------------------------- mark_2EA7: DIM_007: ; 2EA7 LD HL,($0A96) LD A,$4D JR L2EE3 ;------------------------------- PAUSE_007: LD A,$DD JR skip_2EE0 ;------------------------------- SLOW_007: ; 2EB2 LD A,$D6 JR skip_2EB8 ;------------------------------- FAST_007: ; 2EB6 LD A,$CE ;------------------------------- skip_2EB8: PUSH AF CALL STK_TO_A LD B,$1E DEC A CP 6 JR NC,skip_2EDC ;------------------------------- SRL A LD H,A ;------------------------------- JR Z,skip_2ECA LD A,1 skip_2ECA: ;------------------------------- PUSH AF SBC A,A LD L,A RES 1,H DEC H LD (G007_RESTART),HL CALL G007_CHECK_AND_SET_UP_DISPLAY_FILE LD B,G007_INT_REG_VALUE_FOR_HI_RES_GRAPHICS POP AF LD (G007_FLAG_2),A ;------------------------------- skip_2EDC: LD A,B ; LD I,A ; I = B = G007_INT_REG_VALUE_FOR_HI_RES_GRAPHICS = set video mode POP AF ;------------------------------- skip_2EE0: LD HL,($0D71) ; inside the 'COMMAND CLASS 2' routine of the ZX BASIC ROM ;------------------------------- L2EE3: ADD A,L LD L,A JP (HL) LD D,A LD A,(S_POSN) ; AND $80 JP L2B6C ;=============================== L2EEF: ; print a character on high-res screen perhaps? LD A,D POP DE EXX ;------------------------------- PUSH HL PUSH DE PUSH BC ;------------------------------- LD HL,(G007_CHAR_TABLE_ADDR_0_63) ADD A,A ; if (A < 128) goto JR NC,skip_2F06 ;------------------------------- ; LD HL,(G007_CHAR_TABLE_ADDR_128_159) BIT 6,A JR Z,skip_2F06 ;------------------------------- LD HL,(G007_USR_DEF_CHR_TAB_LESS_256) CCF ;------------------------------- skip_2F06: EX DE,HL ; DE now points to the selected charater table LD L,A ; HL = A LD H,0 SBC A,A ; A = carry LD C,A ; ;------------------------------- LD A,(G007_RESTART) ; invert this variable CPL AND A,(IY+G007_RESTART+1-RAMBASE) ;------------------------------- XOR A,C LD C,A ADD HL,HL ; HL *= 4 ADD HL,HL ADD HL,DE ; HD += DE LD B,8 EXX PUSH DE RET ;=============================== L2F1D: ; The copied and modified PRINT_CH / WRITE_CH jumps here from $23FF DEC (IY+S_POSN-RAMBASE) ; Line and Column for PRINT AT LD A,24 ; 24 character rows per screen SUB B LD B,A ; ADD A,A ADD A,A ADD A,A LD L,A ; L = A * 8 ; LD A,(G007_DISPLAY_HEIGHT) SUB L ; A = G007_DISPLAY_HEIGHT - something RET C ; return if beyond limit ;------------------------------- LD A,CHARS_HORIZONTAL+1 ; 32 video bytes plus HALT ? SUB C LD C,A ;------------------------------- LD H,0 ADD HL,HL ADD HL,BC LD BC,(G007_DISPLAY_ADDRESS) ADD HL,BC ; HL = L*2 + BC + G007_DISPLAY_ADDRESS: ;------------------------------- CALL L2EEF LD BC,$0022 ; B = 0, C = 34 EXX ;------------------------------- COPY_007: loop_2F41: ; LD A,C XOR A,(HL) EXX LD (HL),A ADD HL,BC EXX INC HL DJNZ loop_2F41 ;------------------------------- JP L299A ;------------------------------- SAVE_007: ; 2F4D CALL G007_DELETE_DISPLAY_FILE JP SAVE ;------------------------------- L2F53: CALL STK_TO_A RET NZ DEC A JP M,COPY ; A was zero, jump to low-res copy-to-printer ;------------------------------- CALL G007_CHECK_AND_SET_UP_DISPLAY_FILE ; check we have a display CALL SET_FAST ; print in FAST mode! LD A,(G007_DISPLAY_HEIGHT) LD B,A ; B = (G007_DISPLAY_HEIGHT) LD HL,(G007_DISPLAY_ADDRESS) XOR A,A ; A = 0 LD E,A ; E = 0 OUT (ZX_PRINTER_PORT),A ;------------------------------- loop_2F6C: LD A,$7F ; looks pointless IN A,(IO_PORT_KEYBOARD_RD) RRCA JP NC,$0886 ; []*BIOS ROM* between 0880 COPY-BRK and 0888 REPORT-D2 IN A,(ZX_PRINTER_PORT) ;------------------------------- loop_2F76: ADD A,A JP M,L2FAD ;------------------------------- JR NC,loop_2F6C ;------------------------------- LD C,$20 ; 32 ;------------------------------- loop_2F7E: PUSH BC LD C,(HL) LD B,8 ;------------------------------- ; outer loop loop_2F82: RLC C RRA OR A,E LD D,A ;------------------------------- ; inner loop loop_2F87: IN A,(ZX_PRINTER_PORT) ; read printer port bit 0 into carry flag RRA JR NC,loop_2F87 ; repeat while bit is zero ;------------------------------- LD A,D OUT (ZX_PRINTER_PORT),A ; D register to printer DJNZ loop_2F82 ;------------------------------- INC HL POP BC DEC C JR NZ,loop_2F7E ;------------------------------- INC HL INC HL LD A,3 ;------------------------------- CP B JR C,skip_2F9F ;------------------------------- LD E,A DEC E skip_2F9F: ;------------------------------- loop_2F9F: IN A,(ZX_PRINTER_PORT) ; read printer port bit 0 into carry flag RRA JR NC,loop_2F9F ; repeat while bit is zero ;------------------------------- LD A,E OUT (ZX_PRINTER_PORT),A ; E register to printer DJNZ loop_2F6C ;------------------------------- LD A,4 OUT (ZX_PRINTER_PORT),A ;------------------------------- L2FAD: JP SLOW_FAST ; normal EI DJNZ loop_2F76 ;------------------------------- defb $3E ; something to do with the table below? ;------------------------------- TABLE_ONE: ; ; this table is copied to offsets from $2000, $2200, and $2300 ;------------------------------- ; Modify 9 bytes in page 20xx / 00xx: ;------------------------------- L2FB4 : defb (9+1) ; Modify 9 bytes in page 20xx / 00xx: ;------------------------------- ; Original routine Modifications made in page 00xx ; L2FB5: ; 0011 C2;F1;07 JP NZ,PRINT_CH ; old ; 0011 C2;A0;23 JP NZ,L23A0 ; new, jump somewhere in RAM ??? defb $12 defb $A0 defb $13 defb $23 ;------------------------------- L2FB9 ; 0014 F5 07 JP PRINT_SP ; $07F5 ; 2014 A4 23 JP L23A4 ; new, jumps to somewhere in RAM defb $15 defb $A4 defb $16 defb $23 ;------------------------------- ; 003F CB;D9 SET 3,C ; old ; 003F CB;C1 SET 0,C ; new L2FBD: defb $40 L2FBE: defb $C1 ;------------------------------- ; 005F CD;07;02 CALL SLOW_FAST ; 0207 is old ; 005F CD;08;2D CALL SLOW_FAST_007 ; 2D08 is new L2FBF: defb $60 L2FC0: defb $08 L2FC1: defb $61 L2FC2: defb $2D ;------------------------------- ; 0074 2A;0C;40 LD HL,(D_FILE) ; 0074 2A;06:23 LD HL,(G007_DISPLAY_ADDRESS_LESS_9) ; new L2FC3: defb $75 L2FC4: defb $06 defb $76 L2FC6: defb $23 ;------------------------------- ; Modifications made in page 02xx ;------------------------------- L2FC7: defb $01 defb $0A ; 0253 06;0B LD B,$0B ; 2253 06;02 LD B,$02 L2FC9 defb $54 defb $02 ;------------------------------- ; 0283 01;01;19 LD BC,$1901 ; 2283 01;01;C1 LD BC,$C101 L2FCB: defb $85 defb $C1 ;------------------------------- ; 027E CD;92;02 CALL DISPLAY_3 ; 227E CD;73;2D CALL L2D73 ; L2FCD: defb $7F defb $73 L2FCF: defb $80 defb $2D ;------------------------------- ; 028C CD;92;02 CALL $0292 ; [DISPLAY-3] ; 228C CD;50;2D CALL $2D50 L2FD1: defb $8D L2FD2: defb $50 L2FD3: defb $8E L2FD4: defb $2D ;------------------------------- ; 02E3 32;28;40 LD ($4028),A ; SET MARGIN ; 22E3 C3;0E;2D JP L2D0E L2FD5: defb $E3 L2FD6: defb $C3 defb $E4 defb $0E L2FD9: defb $E5 L2FDA: defb $2D ;------------------------------- L2FDB: defb $13 ; some kind of marker? ;------------------------------- ; ; Original routine Modifications made to the copy of the PRINT-CH routines: ; ; ; Variables in the sparsely populated G007 RAM areas ; ; Initialise 18 (decimal, = 12 in hex)RAM variables at $23xx: ; ; 2FE0 E6 0A ; 23E6 0A ; 2FE2 55 0D ; 2355 0D ; 2FE4 1E 0F ; 231E 0F ; 2FE6 16 20 ; 2316 20 ; 2FE8 10 07 ; 2310 07 ; 2FEA 11 08 ; 2311 08 ; 2FEC 18 C0 ; 2318 C0 ; ;------------------ ; G007_DISPLAY_OFFSET_FROM_DFILE_LESS_9 = E675 (6675 echoed in top 32K ???) L2FDC: defb $00 ; 2300 75 defb $75 ;------------------ L2FDE: defb $01 ; 2301 E6 defb $E6 ;------------------ L2FE0: defb $0A ;------------------ L2FE1: defb $55 ; 2355 0D L2FE2: defb $0D ;------------------ L2FE3: defb $1E ; 231E 0F L2FE4: defb $0F ;------------------ defb $1E ; some kind of marker? ;------------------ L2FE6: defb $16 ; 2316 20 defb $20 ;------------------ ; G007_PLOT_ROUTINES_VECTOR = G007_PLOT_ROUTINES_VECTOR_DEFAULT = $0807 L2FE8: defb $10 ; 2310 07 defb $07 ;------------------ L2FEA: defb $11 ; 2311 08 defb $08 ;------------------ L2FEC: defb $18 ; 2318 C0 defb $C0 ;------------------ L2FEE: defb $35 ; 2335 EE defb $EE ;------------------ L2FF0: defb $36 ; 2336 55 defb $55 ;------------------ L2FF2: defb $37 ; 2337 C6 defb $C6 ;------------------ ; The values below were seen in RAM but are not initialised from this table: ; ; 2306 84 4084 G007_DISPLAY_ADDRESS_LESS_9 ; 2307 40 ; 2308 8D 408D G007_DISPLAY_ADDRESS ; 2309 40 ; 230A 55 00 55,00 G007_TRIANGLE_TEXTURE ; 230C 00 1E00 Character table address for CHR$0-63 ; 230D 1E ; 230E 00 1E00 Character table address for CHR$128-159 ; 230F 1E ;------------------ ; Modding offsets in copied code: ;------------------ ; 07FD CD 08 08 CALL $0808 ; [ENTER-CH] ; 23AC CD E6 2E CALL $2EE6 ; L2FF4: defb $AD defb $E6 defb $AE defb $2E ;------------------ ; 0843 FD 35 39 DEC (IY+SPOSN-RAMBASE) ; 23F2 C3 1D 2F JP $2F1D ; L2FF8: defb $F2 defb $C3 defb $F3 defb $1D defb $F4 defb $2F ;------------------ ; ; 083E 77 LD (HL),A ; WRITE-CH ; 23ED 00 NOP ; WRITE-CH modified! ; L2FFE: defb $ED defb $00 ;------------------ ; end of g007 stuff ; #endif #code $3800,$0800 #if 1 mark_3800: DEFB $21, $00, $38 ; ld hl,Source mark_3803: DEFB $11, $00, $78 ; ld de,Destination mark_3806: DEFB $01, $00, $08 ; ld bc,MonitorSize mark_3809: DEFB $ED, $B0 ; ldir mark_380B: DEFB $3E, $74 ; ld a,74 mark_380D: DEFB $32, $05, $40 ; ld (RamtopHi),a mark_3810: DEFB $CD, $C3, $03 ; call New mark_3813: DEFB $3E, $01 ; ld a,01 mark_3815: DEFB $01, $93, $7B ; ld bc,Input_Prompt_Data mark_3818: DEFB $CD, $02, $79 ; call Get_A_addresses mark_381B: DEFB $CD, $2A, $0A ; call Cls mark_381E: DEFB $ED, $6B, $F8, $7F ; ld hl,Next_Address mark_3822: DEFB $E9 ; jp (hl) ; Routine 0 the disassembler mark_3823: DEFB $CD, $FD, $78, $CD, $09 mark_3828: DEFB $79, $18, $05, $16, $13, $CD, $53, $7B mark_3830: DEFB $CD, $81, $7B, $30, $05, $AF, $32, $21 mark_3838: DEFB $40, $C9 mark_383A: DEFB $21, $7B, $40, $36, $30, $23 mark_3840: DEFB $36, $78, $CD, $2E, $7A, $CD, $72, $7A mark_3848: DEFB $78, $FE, $76, $20, $08, $21, $F5, $7C mark_3850: DEFB $CD, $A4, $7B, $18, $D6, $FE, $CB, $28 mark_3858: DEFB $32, $FE, $ED, $28, $38, $FE, $DD, $28 mark_3860: DEFB $44, $FE, $FD, $28, $44, $CD, $4F, $7A mark_3868: DEFB $2E, $24, $FE, $00, $28, $11, $2E, $2C mark_3870: DEFB $FE, $01, $28, $0E, $2C, $FE, $02, $28 mark_3878: DEFB $09, $3E, $5E, $32, $42, $7D, $2C, $7D mark_3880: DEFB $81, $6F, $26, $7D, $6E, $EB, $CD, $D4 mark_3888: DEFB $7A, $18, $A0, $CD, $72, $7A, $CD, $4F mark_3890: DEFB $7A, $C6, $36, $18, $EC, $CD, $72, $7A mark_3898: DEFB $CD, $4F, $7A, $2E, $18, $FE, $01, $28 mark_38A0: DEFB $DE, $2E, $20, $18, $DA, $3E, $0B, $18 mark_38A8: DEFB $02, $3E, $0D, $32, $41, $7D, $3E, $12 mark_38B0: DEFB $32, $40, $7D, $2A, $F8, $7F, $23, $7E mark_38B8: DEFB $21, $16, $7D, $CD, $89, $7A, $23, $CB mark_38C0: DEFB $BE, $CD, $72, $7A, $78, $FE, $CB, $20 mark_38C8: DEFB $05, $CD, $72, $7A, $18, $BD, $CD, $4F mark_38D0: DEFB $7A, $FE, $03, $28, $93, $F5, $C5, $FE mark_38D8: DEFB $00, $20, $05, $3E, $06, $B8, $20, $03 mark_38E0: DEFB $CD, $72, $7A, $C1, $F1, $18, $81 ; Spare bytes mark_38E7: DEFB $00 mark_38E8: DEFB $00, $00, $00, $00, $00, $00, $00, $00 mark_38F0: DEFB $00, $00, $00, $00, $00, $00, $00, $00 mark_38F8: DEFB $00, $00, $00, $00, $00 ; Start/Finish Addresses ; prints request for input then calls input address routine mark_38FD: DEFB $01, $93, $7B mark_3900: DEFB $3E, $02 ; Get_A_addresses mark_3902: DEFB $11, $F8, $7F, $CD, $14, $7A, $C9 ; Check printer mark_3909: DEFB $11, $E1, $10, $CD, $3B, $7B, $2B mark_3910: DEFB $7E, $21, $21, $40, $36, $83, $FD, $CB mark_3918: DEFB $01, $CE, $FE, $1D, $C4, $2A, $0A, $C9 ; routine 1: DEFB hex dump mark_3920: DEFB $CD, $FD, $78, $CD, $09, $79, $21, $F9 mark_3928: DEFB $7C, $CD, $9F, $7B, $21, $7B, $40, $36 mark_3930: DEFB $33, $23, $36, $79, $CD, $81, $7B, $F8 mark_3938: DEFB $CD, $3D, $7A, $0E, $08, $CD, $72, $7A mark_3940: DEFB $0D, $28, $0B, $CD, $81, $7B, $30, $F5 mark_3948: DEFB $16, $0B, $CD, $53, $7B, $C9 mark_394E: DEFB $CD, $48, $79, $18, $E1 ; routine 2: DEFB write mark_3953: DEFB $3E, $01, $01, $93, $7B mark_3958: DEFB $CD, $02, $79, $CD, $2A, $0A, $CD, $0E mark_3960: DEFB $0C, $CD, $3D, $7A, $11, $E8, $1C, $CD mark_3968: DEFB $A5, $7F, $CB, $45, $28, $05, $CD, $AD mark_3970: DEFB $7F, $18, $F7, $ED, $5B, $F8, $7F, $CD mark_3978: DEFB $0B, $7B, $ED, $53, $F8, $7F, $3E, $76 mark_3980: DEFB $D7, $18, $DB ; prints data associated with RST 08 or RST 28 mark_3983: DEFB $0D, $20, $24, $0E, $04 mark_3988: DEFB $16, $13, $CD, $53, $7B, $18, $18, $78 mark_3990: DEFB $FE, $01, $20, $1A, $21, $7B, $40, $36 mark_3998: DEFB $62, $23, $36, $7A, $16, $13, $CD, $53 mark_39A0: DEFB $7B, $21, $F9, $7C, $CD, $9F, $7B, $CD mark_39A8: DEFB $3D, $7A, $CD, $72, $7A, $C9 mark_39AE: DEFB $FE, $05 mark_39B0: DEFB $C0, $21, $7B, $40, $36, $68, $23, $36 mark_39B8: DEFB $7A, $0E, $04, $CD, $9C, $79, $78, $FE mark_39C0: DEFB $34, $C8, $CD, $83, $79, $18, $F7 ; Data Calculates absolute address for JR instructions ; and adds number and addresses to mnemonic mark_39C7: DEFB $CD mark_39C8: DEFB $72, $7A, $AF, $CB, $78, $28, $01, $2F mark_39D0: DEFB $48, $47, $2A, $F8, $7F, $09, $EB, $21 mark_39D8: DEFB $00, $7D, $7B, $CD, $89, $7A, $2B, $7A mark_39E0: DEFB $CD, $89, $7A, $23, $CB, $BE, $2B, $18 mark_39E8: DEFB $1B, $CD, $72, $7A, $2B, $18, $15, $CD mark_39F0: DEFB $07, $7A, $18, $10, $CD, $72, $7A, $2B mark_39F8: DEFB $18, $03, $CD, $07, $7A, $2B, $CD, $A4 mark_3A00: DEFB $7B, $21, $0D, $7C, $C3, $A4, $7B, $21 mark_3A08: DEFB $00, $7D, $CD, $75, $7A, $CD, $72, $7A mark_3A10: DEFB $CB, $BE, $2B, $C9 ; Input_Address mark_3A14: DEFB $F5, $D5, $11, $E4 mark_3A18: DEFB $10, $CD, $3B, $7B, $7D, $BB, $28, $05 mark_3A20: DEFB $CD, $AD, $7F, $18, $F7, $D1, $CD, $21 mark_3A28: DEFB $7B, $F1, $3D, $20, $E7, $C9 ; Initial mark_3A2E: DEFB $21, $42 mark_3A30: DEFB $7D, $36, $5C, $2B, $36, $09, $2B, $36 mark_3A38: DEFB $0F, $2B, $2B, $36, $E0 ; Next_Address mark_3A3D: DEFB $11, $F9, $7F mark_3A40: DEFB $21, $FE, $7C, $1A, $CD, $7F, $7A, $1B mark_3A48: DEFB $1A, $CD, $7F, $7A, $AF, $D7, $C9 ; Octal mark_3A4F: DEFB $78 mark_3A50: DEFB $E6, $07, $4F, $78, $F5, $E6, $38, $0F mark_3A58: DEFB $0F, $0F, $47, $F1, $E6, $C0, $07, $CB mark_3A60: DEFB $07, $C9 ; Cont, $RST mark_3A62: DEFB $CD, $A1, $79, $C3, $2B, $78 mark_3A68: DEFB $0E, $04, $CD, $A1, $79, $CD, $BE, $79 mark_3A70: DEFB $18, $F3 ; Next_Byte mark_3A72: DEFB $21, $FE, $7C, $ED, $5B, $F8 mark_3A78: DEFB $7F, $1A, $13, $ED, $53, $F8, $7F, $CD mark_3A80: DEFB $89, $7A, $D7, $23, $7E, $CB, $BF, $D7 mark_3A88: DEFB $C9 mark_3A89: DEFB $47, $E6, $0F, $C6, $1C, $CB, $FF mark_3A90: DEFB $77, $2B, $78, $E6, $F0, $1F, $1F, $1F mark_3A98: DEFB $1F, $C6, $1C, $77, $C9 ; Offsets mark_3A9D: DEFB $CB, $40, $20 mark_3AA0: DEFB $19, $CD, $B3, $7A, $13, $C9 mark_3AA6: DEFB $3E, $01 mark_3AA8: DEFB $CB, $40, $20, $1E, $18, $05, $CB, $40 mark_3AB0: DEFB $28, $0F, $13, $AF, $18, $14, $CB, $40 mark_3AB8: DEFB $28, $07, $13, $78, $CB, $87, $0F, $18 mark_3AC0: DEFB $09, $CD, $BB, $7A, $13, $C9 mark_3AC7: DEFB $78, $18 mark_3AC8: DEFB $01, $79, $13, $62, $6B, $6E, $26, $7C mark_3AD0: DEFB $CD, $A5, $7B, $C9 ; Control mark_3AD4: DEFB $1A, $F5, $E6, $07 mark_3AD8: DEFB $21, $DD, $7A, $18, $1E, $F1, $F5, $CB mark_3AE0: DEFB $77, $28, $0D, $2A, $3E, $7D, $CB, $55 mark_3AE8: DEFB $36, $00, $23, $28, $F9, $22, $3E, $7D mark_3AF0: DEFB $E6, $38, $0F, $0F, $CB, $0F, $28, $0C mark_3AF8: DEFB $21, $04, $7B, $E5, $3C, $26, $7D, $6F mark_3B00: DEFB $6E, $26, $7A, $E9, $F1, $CB, $7F, $C0 mark_3B08: DEFB $13, $18, $C9 ; Transfer mark_3B0B: DEFB $C5, $7D, $2E, $E0, $95 mark_3B10: DEFB $0F, $47, $7E, $CD, $8C, $7B, $23, $86 mark_3B18: DEFB $D6, $1C, $12, $13, $23, $10, $F3, $C1 mark_3B20: DEFB $C9 mark_3B21: DEFB $C5, $06, $02, $2B, $4E, $2B, $7E mark_3B28: DEFB $CD, $8C, $7B, $81, $D6, $1C, $12, $13 mark_3B30: DEFB $10, $F2, $C1, $3E, $76, $D7, $D7, $C9 mark_3B38: DEFB $11, $EF, $10, $CD, $33, $78, $26, $7E mark_3B40: DEFB $0A, $6F, $CD, $9F, $7B, $03, $0A, $6F mark_3B48: DEFB $03, $CD, $A4, $7B, $CD, $53, $7B, $CD mark_3B50: DEFB $A5, $7F, $C9 ; Print_String mark_3B53: DEFB $C5, $D5, $E5, $FD, $CB mark_3B58: DEFB $21, $46, $28, $08, $ED, $4B, $39, $40 mark_3B60: DEFB $4A, $CD, $0B, $09, $11, $E0, $7F, $ED mark_3B68: DEFB $4B, $3E, $7D, $06, $00, $79, $D6, $E0 mark_3B70: DEFB $4F, $CD, $6B, $0B, $FD, $CB, $21, $4E mark_3B78: DEFB $28, $03, $3E, $76, $D7, $E1, $D1, $C1 mark_3B80: DEFB $C9 ; Check_Finish mark_3B81: DEFB $2A, $FA, $7F, $ED, $5B, $F8, $7F mark_3B88: DEFB $A7, $ED, $52, $C9 mark_3B8C: DEFB $D6, $1C, $07, $07 mark_3B90: DEFB $07, $07, $C9 ; data for input prompt messages mark_3B93: DEFB $DD, $E3, $EB, $E3, $F2 mark_3B98: DEFB $F8, $D5, $DC, $30, $E3, $D0, $E3 ; Add_String, for building mnemonic mark_3B9F: DEFB $3E mark_3BA0: DEFB $E0, $32, $3E, $7D, $AF, $C5, $D5, $A7 mark_3BA8: DEFB $28, $0B, $CB, $7E, $20, $03, $23, $18 mark_3BB0: DEFB $F9, $3D, $23, $18, $F2, $CD, $BB, $7B mark_3BB8: DEFB $D1, $C1, $C9 mark_3BBB: DEFB $ED, $5B, $3E, $7D, $7E mark_3BC0: DEFB $CB, $7F, $20, $05, $CD, $CB, $7B, $18 mark_3BC8: DEFB $F2, $CB, $BF, $FE, $40, $30, $08, $12 mark_3BD0: DEFB $13, $ED, $53, $3E, $7D, $23, $C9 mark_3BD7: DEFB $23 mark_3BD8: DEFB $ED, $53, $3E, $7D, $E5, $FE, $43, $30 mark_3BE0: DEFB $06, $26, $7D, $6F, $6E, $18, $14, $FE mark_3BE8: DEFB $64, $30, $05, $26, $7D, $6F, $18, $0B mark_3BF0: DEFB $21, $FE, $7B, $E5, $26, $7D, $6F, $6E mark_3BF8: DEFB $26, $79, $E9, $CD, $BB, $7B, $E1, $C9 ; ; data for mnemonics ; lower case are ZX inverse characters ; mark_3C00: DEFB $A7, $A8, $A9, $AA, $AD, $B1, $C0, $A6 mark_3C08: DEFB $A6, $C1, $A6, $10, $43, $91, $10, $45 mark_3C10: DEFB $91, $E7, $E7, $C3, $C5, $C1, $C2, $62 mark_3C18: DEFB $A8, $45, $A8, $47, $D6, $49, $D6, $47 mark_3C20: DEFB $A6, $49, $A6, $29, $26, $A6, $28, $35 mark_3C28: DEFB $B1, $38, $28, $AB, $28, $28, $AB, $9C mark_3C30: DEFB $9D, $9E, $9F, $A0, $A1, $A2, $A3, $35 mark_3C38: DEFB $3A, $38, $AD, $56, $31, $B1, $37, $2A mark_3C40: DEFB $B9, $4B, $BD, $2F, $B5, $CD, $58, $A9 mark_3C48: DEFB $58, $A8, $38, $3A, $A7, $38, $C3, $26 mark_3C50: DEFB $33, $A9, $3D, $34, $B7, $34, $B7, $28 mark_3C58: DEFB $B5, $35, $34, $B5, $37, $38, $B9, $2F mark_3C60: DEFB $B5, $80, $D3, $E2, $CB, $CB, $29, $AE mark_3C68: DEFB $2A, $AE, $E5, $E8, $66, $1A, $A6, $4F mark_3C70: DEFB $E6, $10, $5C, $11, $DA, $45, $DA, $80 mark_3C78: DEFB $80, $10, $41, $91, $5C, $DA, $CF, $CF mark_3C80: DEFB $80, $CF, $80, $80, $80, $80, $33, $BF mark_3C88: DEFB $BF, $33, $A8, $A8, $35, $B4, $35, $AA mark_3C90: DEFB $B5, $B2, $47, $A8, $49, $A8, $C7, $C9 mark_3C98: DEFB $38, $31, $A6, $38, $37, $A6, $E4, $38 mark_3CA0: DEFB $C7, $27, $2E, $B9, $37, $2A, $B8, $38 mark_3CA8: DEFB $2A, $B9, $10, $28, $91, $33, $2A, $AC mark_3CB0: DEFB $B3, $AE, $38, $C3, $58, $A8, $2E, $B2 mark_3CB8: DEFB $9C, $A4, $9D, $9E, $CD, $CD, $CD, $CD mark_3CC0: DEFB $49, $A9, $47, $A9, $2E, $9A, $37, $9A mark_3CC8: DEFB $CF, $CF, $80, $80, $5E, $1A, $DE, $E9 mark_3CD0: DEFB $E9, $E0, $E0, $E0, $E0, $A6, $A6, $AE mark_3CD8: DEFB $B7, $80, $80, $AE, $A9, $2E, $B7, $29 mark_3CE0: DEFB $B7, $CD, $28, $B5, $E2, $D3, $34, $B9 mark_3CE8: DEFB $33, $34, $B5, $CB, $29, $2F, $33, $BF mark_3CF0: DEFB $D1, $D1, $D1, $D1, $D1, $2D, $26, $31 mark_3CF8: DEFB $B9, $45, $2B, $A7, $10, $1D, $A9, $27 ; ; data and data pointers for disassembler ; mark_3D00: DEFB $9F, $A6, $C9, $B3, $AE, $BB, $9D, $B6 mark_3D08: DEFB $C6, $2D, $B1, $2E, $BD, $2E, $BE, $10 mark_3D10: DEFB $41, $91, $10, $41, $15, $2A, $27, $91 mark_3D18: DEFB $CD, $D3, $D9, $DF, $3C, $E8, $EB, $EE mark_3D20: DEFB $F3, $F3, $F3, $F5, $91, $81, $89, $6D mark_3D28: DEFB $6A, $F9, $7B, $3A, $70, $9C, $A1, $76 mark_3D30: DEFB $A4, $AA, $AD, $FC, $B3, $96, $B8, $BB mark_3D38: DEFB $C1, $C7, $87, $1B, $81, $A1, $E4, $7F mark_3D40: DEFB $0F, $09, $5C, $27, $A8, $29, $AA, $37 mark_3D48: DEFB $B1, $37, $B7, $2A, $BD, $31, $A9, $26 mark_3D50: DEFB $9A, $2F, $B7, $34, $3A, $B9, $28, $A6 mark_3D58: DEFB $26, $A9, $1A, $C1, $38, $B5, $26, $AB mark_3D60: DEFB $1A, $E9, $2E, $B3, $E9, $EF, $F4, $FA mark_3D68: DEFB $8F, $C7, $FA, $17, $00, $E0, $17, $13 mark_3D70: DEFB $7A, $45, $00, $8A, $C5, $00, $F5, $59 mark_3D78: DEFB $3E, $13, $77, $7A, $45, $00, $92, $C5 mark_3D80: DEFB $9E, $58, $45, $13, $15, $AA, $C5, $6A mark_3D88: DEFB $13, $72, $45, $0B, $07, $B2, $C5, $07 mark_3D90: DEFB $0B, $7F, $E8, $82, $87, $CB, $62, $5C mark_3D98: DEFB $2F, $90, $B8, $6B, $7F, $46, $7E, $81 mark_3DA0: DEFB $00, $FA, $3E, $86, $7A, $43, $86, $92 mark_3DA8: DEFB $C5, $6A, $FF, $5F, $6A, $7A, $3B, $86 mark_3DB0: DEFB $92, $C5, $6A, $7F, $46, $7E, $82, $9E mark_3DB8: DEFB $CF, $92, $00, $7A, $A1, $2F, $8A, $C5 mark_3DC0: DEFB $00, $7A, $A4, $2F, $8A, $C5, $00, $7A mark_3DC8: DEFB $A7, $2F, $8A, $C5, $00, $7A, $63, $00 mark_3DD0: DEFB $92, $C5, $AA, $52, $62, $AA, $BA, $C5 mark_3DD8: DEFB $00, $50, $B2, $15, $A2, $C5, $13, $6A mark_3DE0: DEFB $45, $11, $13, $9A, $C5, $13, $11, $00 mark_3DE8: DEFB $BA, $3E, $B0, $FA, $B6, $B8, $7F, $BC mark_3DF0: DEFB $C4, $87, $D5, $B9, $E1, $D7, $BC, $E2 mark_3DF8: DEFB $D7, $FA, $19, $00, $D8, $37, $13, $6A ; ; print data for menu & routines ; mark_3E00: DEFB $00, $00, $00, $00, $32, $2A, $33, $BA mark_3E08: DEFB $00, $00, $00, $00, $14, $14, $14, $94 mark_3E10: DEFB $1C, $00, $35, $37, $2E, $33, $39, $00 mark_3E18: DEFB $28, $34, $29, $AA, $1D, $00, $2D, $2A mark_3E20: DEFB $3D, $00, $29, $3A, $32, $B5, $1E, $00 mark_3E28: DEFB $3C, $37, $2E, $39, $AA, $1F, $00, $2E mark_3E30: DEFB $33, $38, $2A, $37, $B9, $20, $00, $29 mark_3E38: DEFB $2A, $31, $2A, $39, $AA, $21, $00, $39 mark_3E40: DEFB $37, $26, $33, $38, $2B, $2A, $B7, $22 mark_3E48: DEFB $00, $38, $2A, $26, $37, $28, $AD, $23 mark_3E50: DEFB $00, $37, $2A, $35, $31, $26, $28, $AA mark_3E58: DEFB $24, $00, $26, $38, $38, $2A, $32, $27 mark_3E60: DEFB $31, $2A, $B7, $25, $00, $37, $3A, $33 mark_3E68: DEFB $00, $28, $34, $29, $AA, $26, $00, $28 mark_3E70: DEFB $26, $31, $28, $3A, $31, $26, $39, $34 mark_3E78: DEFB $B7, $27, $00, $28, $2D, $37, $0D, $00 mark_3E80: DEFB $29, $3A, $32, $B5, $28, $00, $26, $38 mark_3E88: DEFB $28, $2E, $2E, $00, $29, $3A, $32, $B5 mark_3E90: DEFB $29, $00, $37, $2A, $33, $3A, $32, $27 mark_3E98: DEFB $2A, $B7, $2A, $00, $2E, $32, $26, $2C mark_3EA0: DEFB $2A, $B7, $2B, $00, $32, $2A, $33, $3A mark_3EA8: DEFB $00, $9E, $80, $80, $00, $00, $00, $00 mark_3EB0: DEFB $00, $00, $00, $00, $00, $00, $00, $00 mark_3EB8: DEFB $00, $00, $00, $00, $00, $00, $00, $00 mark_3EC0: DEFB $00, $00, $00, $00, $00, $00, $00, $00 mark_3EC8: DEFB $00, $00, $00, $00, $00, $00, $00, $00 mark_3ED0: DEFB $31, $2E, $32, $2E, $B9, $37, $34, $3A mark_3ED8: DEFB $39, $2E, $33, $2A, $80, $38, $39, $26 mark_3EE0: DEFB $37, $39, $80, $26, $29, $29, $37, $2A mark_3EE8: DEFB $38, $38, $80, $2B, $2E, $33, $2E, $38 mark_3EF0: DEFB $2D, $80, $1D, $00, $2B, $34, $37, $80 mark_3EF8: DEFB $35, $37, $2E, $33, $39, $2A, $37, $80 ; addresses of routines mark_3F00: DEFB $23, $78 ;, $.dw, $7823 mark_3F02: DEFB $20, $79 ; , $.dw, $7902 mark_3F04: DEFB $53, $79 ;, $.dw, $7953 mark_3F06: DEFB $FF, $FF mark_3F08: DEFB $FF, $FF mark_3F0A: DEFB $FF, $FF mark_3F0C: DEFB $FF, $FF mark_3F0E: DEFB $FF, $FF mark_3F10: DEFB $FF, $FF mark_3F12: DEFB $13, $38 ;, $.dw, $3813 mark_3F14: DEFB $FF, $FF mark_3F16: DEFB $FF, $FF mark_3F18: DEFB $FF, $FF mark_3F1A: DEFB $FF, $FF mark_3F1C: DEFB $FF, $FF mark_3F1E: DEFB $FF, $FF ; Read_Keyboard mark_3F20: DEFB $D5, $C5, $E5, $2A, $25, $40, $E5, $ED mark_3F28: DEFB $4B, $25, $40, $E1, $C5, $A7, $ED, $42 mark_3F30: DEFB $28, $F5, $79, $3C, $28, $F1, $E1, $CD mark_3F38: DEFB $BD, $07, $7E, $E1, $C1, $D1, $FE, $76 mark_3F40: DEFB $C8, $FE, $77, $C8, $FE, $00, $20, $05 mark_3F48: DEFB $CD, $2A, $0A, $CF, $0C, $FE, $1C, $38 mark_3F50: DEFB $CF, $FE, $2C, $30, $CB, $C9 ; ; Menu ; mark_3F56: DEFB $21, $21 mark_3F58: DEFB $40, $CB, $7E, $28, $04, $2A, $7B, $40 mark_3F60: DEFB $E9, $21, $00, $7E, $06, $14, $3E, $03 mark_3F68: DEFB $32, $21, $40, $11, $E1, $18, $CD, $9F mark_3F70: DEFB $7B, $CD, $53, $7B, $10, $F8, $01, $99 mark_3F78: DEFB $7B, $CD, $3B, $7B, $2B, $7E, $D6, $1C mark_3F80: DEFB $47, $07, $6F, $26, $7F, $7E, $23, $66 mark_3F88: DEFB $6F, $E5, $C5, $CD, $2A, $0A, $C1, $3E mark_3F90: DEFB $E0, $32, $3E, $7D, $78, $21, $10, $7E mark_3F98: DEFB $CD, $A5, $7B, $16, $1A, $CD, $53, $7B mark_3FA0: DEFB $3E, $76, $D7, $D7, $C9 ; ; InputString, the heart of all routines ; mark_3FA5: DEFB $3E, $01, $32 mark_3FA8: DEFB $21, $40, $21, $E0, $7F, $36, $17, $CD mark_3FB0: DEFB $C0, $7F, $CD, $20, $7F, $FE, $76, $20 mark_3FB8: DEFB $10, $3E, $E0, $BD, $28, $F4, $36, $00 mark_3FC0: DEFB $23, $22, $3E, $7D, $CD, $53, $7B, $2B mark_3FC8: DEFB $C9 mark_3FC9: DEFB $FE, $77, $20, $0B, $3E, $E0, $BD mark_3FD0: DEFB $28, $DB, $CD, $BE, $7F, $2B, $18, $D5 mark_3FD8: DEFB $77, $7B, $BD, $28, $D0, $23, $18, $CD ; ; mnemonic string, ram area for mnemonic to be built up ; mark_3FE0: DEFB $00, $00, $00, $00, $00, $00, $00, $00 mark_3FE8: DEFB $00, $00, $00, $00, $00, $00, $00, $00 ; ; spare bytes ; mark_3FF0: DEFB $00, $00, $00, $00, $00, $00, $00, $00 ; ; next address for routine ; mark_3FF8: DEFB $00, $00 ; ; finish address for routine ; mark_3FFA: DEFB $00, $00 ; ; spare bytes ; mark_3FFC: DEFB $00, $00, $00 mark_3FFF: DEFB $C9 ; ret #else ; ; ; Input_Prompt_Data equ $7B93 Get_A_addresses equ $7902 Next_Address equ $7FFB #endif #end ; required by zasm