Apple-2-SW/AppleIIAsm-Collection
1
0
Fork 0
mirror of https://github.com/nathanriggs/AppleIIAsm-Collection.git synced 2024-06-02 06:41:34 +00:00
Code Issues Projects Releases Wiki Activity

Disk 3: ARRAYS 0.3.0 updates

Browse Source 
- major bugfixes, especially in 2D arrays
- separated each subroutine into own file
- reconfigured arrays to use 1-based indexing
- Arrays.demo uses macros now
- added overflow error handling to get and put routines
This commit is contained in:
nathanriggs 2019-01-20 19:14:17 -05:00
parent 12a0b19398
commit ad58479739
33 changed files with 7689 additions and 5922 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
bin/d3_arrays.dsk
View File

Binary file not shown.

4777
disks/disk3_arrays/ARRAYS.DEMO
View File

File diff suppressed because it is too large Load Diff

4447
disks/disk3_arrays/ARRAYS.DEMO.S
View File

File diff suppressed because it is too large Load Diff

30
disks/disk3_arrays/MINIFY Normal file
View File

@ -0,0 +1,30 @@
5 HOME
8 ONERR GOTO 1000
10 PRINT "ASSEMBLY CODE MINIFIER"
20 PRINT "-=-=-=-=-=-=-=-=-=-=-="
30 PRINT
35 DIM FC$(1000):C = 0
40 INPUT "ENTER THE SOURCE FILE NAME: ";FF$
50 INPUT "ENTER THE DESTINATION FILE NAME: ";DD$
55 PRINT "WORKING.."
60 PRINT CHR$ (4);"OPEN ";FF$
70 PRINT CHR$ (4);"READ ";FF$
80 GET AA$
85 REM ? CHR$ (34);".";
90 IF AA$ = CHR$ (13) THEN GOTO 200
95 S$ = S$ + AA$
110 GOTO 80
200 IF LEFT$ (S$,1) = "*" OR LEFT$ (S$,1) = ";" THEN S$ = ""
500 FC$(C) = S$
510 S$ = ""
520 C = C + 1
990 GOTO 80
1000 PRINT : PRINT CHR$ (4);"CLOSE ";FF$
1010 PRINT CHR$ (4);"OPEN ";DD$
1020 PRINT CHR$ (4);"WRITE ";DD$
1030 FOR Z = 0 TO C
1040 IF FC$(Z) < > "" THEN PRINT FC$(Z)
1050 NEXT Z
1060 PRINT CHR$ (4);"CLOSE ";DD$
1070 PRINT "DONE!": PRINT : PRINT : PRINT
1080 PRINT CHR$ (7): PRINT CHR$ (7): PRINT CHR$ (7)

14
disks/disk3_arrays/T.ADIM81 → disks/disk3_arrays/T.ADIM81.SUB
View File

@ -31,6 +31,8 @@
* PHA *
* LDA #2 ; ELEMENT SIZE *
* PHA *
* LDA #$AA ; FILL VALUE *
* PHA *
* JSR DIM81 *
*- -*
* ENTRY *
@ -39,6 +41,7 @@
* *
* LOW BYTE OF RETURN ADDRESS *
* HI BYTE OF RETURN ADDRESS *
* FILL VALUE *
* ELEMENT SIZE *
* ARRAY SIZE *
* LOW BYTE OF ARRAY ADDRESS *
@ -61,10 +64,6 @@
*
ADIM81
*
** FIRST, CLEAR BLOCK OF MEM TO BE USED
** THEN MUL [:ASIZE] BY [:ESIZE], AND ADD 2 TO
** GET TOTAL MEMORY USED BY ARRAY
*
** SAVE RETURN ADDRESS
*
PLA
@ -74,6 +73,8 @@ ADIM81
*
** GET PARAMETERS
*
PLA
STA :FILL ; FILL VALUE
PLA
STA :ESIZE ; ELEMENT SIZE
STA :ESZBAK
@ -81,7 +82,7 @@ ADIM81
STA :ASIZE ; ARRAY SIZE
STA :ASZBAK
PLA
STA ADDR1
STA ADDR1 ; ARRAY ADDRESS
PLA
STA ADDR1+1
LDY #0
@ -124,7 +125,7 @@ ADIM81
*
** FILL WHOLE PAGES FIRST
*
LDA #0 ; FILL VALUE
LDA :FILL ; FILL VALUE
LDX :MSIZE+1
BEQ :PART ; IF NO WHOLE PAGES, JUST PART
LDY #0
@ -192,4 +193,5 @@ ADIM81
:ESIZE DS 1
:ASZBAK DS 1
:ESZBAK DS 1
:FILL DS 1
*

51
disks/disk3_arrays/T.ADIM81.MIN → disks/disk3_arrays/T.ADIM81.SUB.MIN
View File

@ -1,17 +1,18 @@
SKP 10
ADIM81
PLA
STA RETADR
PLA
STA RETADR+1
PLA
STA :ESIZE
STA :FILL ; FILL VALUE
PLA
STA :ESIZE ; ELEMENT SIZE
STA :ESZBAK
PLA
STA :ASIZE
STA :ASIZE ; ARRAY SIZE
STA :ASZBAK
PLA
STA ADDR1
STA ADDR1 ; ARRAY ADDRESS
PLA
STA ADDR1+1
LDY #0
@ -35,33 +36,33 @@ ADIM81
BNE :LP
CLC
INX
INX
BCC :NOINY
INX ; INCREASE BY TWO
; TO MAKE ROOM FOR SIZES
BCC :NOINY ; IF .X ROLLS OVER, INC .Y
INY
:NOINY
STX :MSIZE
STY :MSIZE+1
LDA #0
STX :MSIZE ; LOW BYTE
STY :MSIZE+1 ; HIGH BYTE
LDA :FILL ; FILL VALUE
LDX :MSIZE+1
BEQ :PART
BEQ :PART ; IF NO WHOLE PAGES, JUST PART
LDY #0
:FULL
STA (ADDR1),Y
INY
BNE :FULL
INC ADDR1+1
INY ; NEXT BYTE
BNE :FULL ; LOOP UNTIL PAGE DONE
INC ADDR1+1 ; GO TO NEXT PAGE
DEX
BNE :FULL
BNE :FULL ; LOOP IF PAGES LEFT
:PART
LDX :MSIZE
BEQ :MFEXIT
LDX :MSIZE ; PARTIAL PAGE BYTES
BEQ :MFEXIT ; EXIT IF = 0
LDY #0
:PARTLP
STA (ADDR1),Y
INY
DEX
BNE :PARTLP
STA (ADDR1),Y ; STORE VAL
INY ; INC INDEX
DEX ; DEC COUNTER
BNE :PARTLP ; LOOP UNTIL DONE
:MFEXIT
LDY #0
LDA :ASZBAK
@ -73,19 +74,19 @@ ADIM81
PHA
LDA RETADR
PHA
LDY ADDR1
LDX ADDR1+1
LDY ADDR1 ; LOW
LDX ADDR1+1 ; HIGH
LDA :ASZBAK
LDA :MSIZE
STA RETURN
LDA :MSIZE+1
STA RETURN+1
LDA #2
STA RETLEN
STA RETLEN ; 2 BYTE LENGTH
RTS
:MSIZE DS 2
:ASIZE DS 1
:ESIZE DS 1
:ASZBAK DS 1
:ESZBAK DS 1
SKP 10
:FILL DS 1

12
disks/disk3_arrays/T.DIM82 → disks/disk3_arrays/T.ADIM82.SUB
View File

@ -1,6 +1,6 @@
*
*``````````````````````````````*
* DIM82 : INIT 2D ARRAY *
* ADIM82 : INIT 2D ARRAY *
*- -*
* THIS SIMPLY CREATES A 1D *
* ARRAY WITH THE DIM OF *
@ -31,6 +31,8 @@
* PHA *
* LDA #1 ; ELEMENT BYTESIZE *
* PHA *
* LDA #$AA ; FILL CHAR *
* PHA *
* JSR DIM82 *
*- -*
* ENTRY *
@ -39,6 +41,7 @@
* *
* LOW BYTE OF RETURN ADDRESS *
* HI BYTE OF RETURN ADDRESS *
* FILL VALUE *
* ELEMENT SIZE IN BYTES *
* Y DIMENSION BOUNDARY *
* X DIMENSION BOUNDARY *
@ -63,7 +66,7 @@
* OF THE RETURN VALUE. *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
DIM82
ADIM82
*
** SAVE RETURN ADDRESS
*
@ -74,6 +77,8 @@ DIM82
*
** GET PARAMETERS
*
PLA
STA :FILL
PLA
STA :MCAND ; ELEMENT LENGTH
PLA
@ -158,7 +163,7 @@ DIM82
*
** NOW CLEAR MEMORY BLOCKS, WHOLE PAGES FIRST
*
LDA #$00 ; FILL VALUE
LDA :FILL ; FILL VALUE
LDX :PROD+1 ; NOTE THAT THIS WON'T
; GO BEYOND A 16BIT VALUE;
; ANYTHING HIGHER THAN
@ -235,4 +240,5 @@ DIM82
:AYBAK DS 1
:MLIER DS 2
:MCAND DS 2
:FILL DS 1
*

133
disks/disk3_arrays/T.ADIM82.SUB.MIN Normal file
View File

@ -0,0 +1,133 @@
ADIM82
PLA
STA RETADR
PLA
STA RETADR+1
PLA
STA :FILL
PLA
STA :MCAND ; ELEMENT LENGTH
PLA
STA :AYSIZE
STA :AYBAK
PLA
STA :AXSIZE
STA :AXBAK
PLA
STA ADDR1
PLA
STA ADDR1+1
LDA #0
STA :MCAND+1
LDA #0
TAY
STY SCRATCH
BEQ :ENTLP
:DOADD
CLC
ADC :AXSIZE
TAX
TYA
ADC SCRATCH
TAY
TXA
:LP
ASL :AXSIZE
ROL SCRATCH
:ENTLP
LSR :AYSIZE
BCS :DOADD
BNE :LP
STX :MLIER
STY :MLIER+1
LDA #0
STA :PROD
STA :PROD+1
STA :PROD+2
STA :PROD+3
LDX #$10
:SHIFTR LSR :MLIER+1
ROR :MLIER
BCC :ROTR
LDA :PROD+2
CLC
ADC :MCAND
STA :PROD+2
LDA :PROD+3
ADC :MCAND+1
:ROTR
ROR
STA :PROD+3
ROR :PROD+2
ROR :PROD+1
ROR :PROD
DEX
BNE :SHIFTR
CLC
INC :PROD ; INCREASE BY 3
INC :PROD
INC :PROD
BCC :NOCAR
INC :PROD+1
:NOCAR
LDA :FILL ; FILL VALUE
LDX :PROD+1 ; NOTE THAT THIS WON'T
; GO BEYOND A 16BIT VALUE;
; ANYTHING HIGHER THAN
; 16BITS IS MORE THAN
; THERE IS MEMORY IN A
; STANDARD APPLE ][
BEQ :PART
LDY #0
:FULL
STA (ADDR1),Y
INY
BNE :FULL
INC ADDR1+1
DEX
BNE :FULL ; LOOP UNTIL PAGES DONE
:PART
LDX :PROD
BEQ :MFEXIT
LDY #0
:PARTLP
STA (ADDR1),Y
INY
DEX
BNE :PARTLP ; LOOP UNTIL DONE
:MFEXIT
LDY #0
LDA :AXBAK
STA (ADDR1),Y
INY
LDA :AYBAK
STA (ADDR1),Y
INY
LDA :MCAND
STA (ADDR1),Y
LDA RETADR+1
PHA
LDA RETADR
PHA
LDY ADDR1
LDX ADDR1+1
LDA :PROD
STA RETURN
LDA :PROD+1
STA RETURN+1
LDA :PROD+2
STA RETURN+2
LDA :PROD+3
STA RETURN+3
LDA #4 ; SIZE OF RETURN
STA RETLEN
LDA :MCAND
RTS
:PROD DS 4
:AXSIZE DS 1
:AYSIZE DS 1
:AXBAK DS 1
:AYBAK DS 1
:MLIER DS 2
:MCAND DS 2
:FILL DS 1

46
disks/disk3_arrays/T.AGET81 → disks/disk3_arrays/T.AGET81.SUB
View File

@ -63,6 +63,7 @@ AGET81
*
PLA
STA :IDX
DEC :IDX
PLA
STA ADDR1
PLA
@ -70,12 +71,49 @@ AGET81
LDA #0
STA :IDX+1
*
** GET ELEMENT SIZE
** GET ELEMENT SIZE, ARRAY SIZE
*
LDY #1 ; ELEMENT SIZE LOC
LDA (ADDR1),Y
STA :ESIZE
STA RETLEN ; LENGTH OF RETURN VALUE
DEY
LDA (ADDR1),Y
STA :ALEN
*
********************************
*
* ERROR CONTROL
*
********************************
*
LDA ERRCTRL
CMP #1
BEQ :CHKERR
JMP :ERREND
:CHKERR
LDA :IDX ; IF IDX > ARRAY LENGTH
CLC
ADC #1
CMP :ALEN
BCS :OVF
JMP :CHKCONT
:OVF
_ERR :E_SID;:E_OVF1;:E_DUMP;:RES;#6
:CHKCONT
LDA :IDX
CMP #255 ; NO ZERO INDEX
BEQ :UNF ; UNDERFLOW
JMP :ERREND
:UNF
_ERR :E_SID;:E_UNF;:E_DUMP;:RES;#6
*
********************************
*
:ERREND
*
********************************
*
*
** FIRST, MUL INDEX BY ELEMENT SIZE,
** THEN ADD TWO TO GET THE PROPER ADDRESS.
@ -167,4 +205,10 @@ AGET81
:RES DS 2
:IDX DS 2
:ESIZE DS 1
:ALEN DS 1
*
:E_SID ASC "AGET81 (GET81 MACRO)",00
:E_DUMP ASC "DUMPING RES(2) IDX(2) ESIZE(1) ALEN(1)",00
:E_OVF1 ASC "OVERFLOW: INDEX HIGHER THAN ARRAY LENGTH",00
:E_UNF ASC "UNDERFLOW: CANNOT USE A ZERO INDEX",00
*

40
disks/disk3_arrays/T.AGET81.MIN → disks/disk3_arrays/T.AGET81.SUB.MIN
View File

@ -5,16 +5,41 @@ AGET81
STA RETADR+1
PLA
STA :IDX
DEC :IDX
PLA
STA ADDR1
PLA
STA ADDR1+1
LDA #0
STA :IDX+1
LDY #1
LDY #1 ; ELEMENT SIZE LOC
LDA (ADDR1),Y
STA :ESIZE
STA RETLEN
STA RETLEN ; LENGTH OF RETURN VALUE
DEY
LDA (ADDR1),Y
STA :ALEN
LDA ERRCTRL
CMP #1
BEQ :CHKERR
JMP :ERREND
:CHKERR
LDA :IDX ; IF IDX > ARRAY LENGTH
CLC
ADC #1
CMP :ALEN
BCS :OVF
JMP :CHKCONT
:OVF
_ERR :E_SID;:E_OVF1;:E_DUMP;:RES;#6
:CHKCONT
LDA :IDX
CMP #255 ; NO ZERO INDEX
BEQ :UNF ; UNDERFLOW
JMP :ERREND
:UNF
_ERR :E_SID;:E_UNF;:E_DUMP;:RES;#6
:ERREND
LDY #0
LDA #0
TAY
@ -46,7 +71,7 @@ AGET81
STA :RES+1
CLC
LDA :RES
ADC ADDR1
ADC ADDR1 ; LOW OF ARRAY ADDRESS
STA :RES
LDA :RES+1
ADC ADDR1+1
@ -61,8 +86,8 @@ AGET81
STA RETURN,Y
INY
CPY RETLEN
BCC :LDLOOP
BEQ :LDLOOP
BCC :LDLOOP ; IF .Y <= RETLEN
BEQ :LDLOOP ; KEEP LOOPING
LDA RETADR+1
PHA
LDA RETADR
@ -74,3 +99,8 @@ AGET81
:RES DS 2
:IDX DS 2
:ESIZE DS 1
:ALEN DS 1
:E_SID ASC "AGET81 (GET81 MACRO)",00
:E_DUMP ASC "DUMPING RES(2) IDX(2) ESIZE(1) ALEN(1)",00
:E_OVF1 ASC "OVERFLOW: INDEX HIGHER THAN ARRAY LENGTH",00
:E_UNF ASC "UNDERFLOW: CANNOT USE A ZERO INDEX",00

97
disks/disk3_arrays/T.AGET82 → disks/disk3_arrays/T.AGET82.SUB
View File

@ -73,23 +73,77 @@ AGET82
STA ADDR1
PLA
STA ADDR1+1
DEC :XIDX
DEC :YIDX
*
** GET ARRAY SIZES
*
LDY #2
LDA (ADDR1),Y ; ELEMENT LENGTH
STA :MCAND ; ELEMENT LENGTH
STA :ELEN
DEY
LDA (ADDR1),Y ; Y LENGTH
STA :YLEN
DEY
LDA (ADDR1),Y ; X LENGTH
STA :XLEN
LDA #0
STA :MCAND+1
*
** MULTIPLY X AND Y
********************************
*
* ERROR CONTROL
*
********************************
*
LDA ERRCTRL
CMP #1
BEQ :CHKERR
JMP :ERREND
:CHKERR
LDA :XIDX ; IF X > MAX LEN
CLC
ADC #1
CMP :XLEN
BCS :XOVF
JMP :ERRCONT1
:XOVF
_ERR :E_SID;:E_XOVF;:E_DUMP;:XIDX;#15
:ERRCONT1
LDA :YIDX ; IF Y > MAX LEN
CLC
ADC #1
CMP :YLEN
BCS :YOVF
JMP :ERRCONT2
:YOVF
_ERR :E_SID;:E_YOVF;:E_DUMP;:XIDX;#15
:ERRCONT2
LDA :XIDX ; IF INDEX IS 0, ERR
CMP #255
BEQ :XOVF
:ERRCONT3
LDA :YIDX
CMP #255
BEQ :YOVF
*
********************************
*
:ERREND
*
********************************
*
** MULTIPLY Y-INDEX BY Y-LENGTH
LDA #0
*
TAY
STY SCRATCH
BEQ :ENTLP
*
:DOADD
CLC
ADC :XIDX
ADC :YIDX
TAX
*
TYA
@ -98,16 +152,28 @@ AGET82
TXA
*
:LP
ASL :XIDX
ASL :YIDX
ROL SCRATCH
:ENTLP
LSR :YIDX
LSR :YLEN
BCS :DOADD
BNE :LP
*
STX :MLIER
STY :MLIER+1
*
** NOW ADD X INDEX
*
CLC
LDA :MLIER
ADC :XIDX
STA :MLIER
BCC :CONTADD
LDA :MLIER+1
ADC #1
STA :MLIER+1
:CONTADD
*
** NOW MULTIPLY BY LENGTH OF ELEMENTS
*
LDA #0
@ -155,6 +221,17 @@ AGET82
*
LDY :PROD
LDX :PROD+1
STY ADDR1
STX ADDR1+1
LDY #0
:RLP
LDA (ADDR1),Y
STA RETURN,Y
INY
CPY :ELEN
BNE :RLP
LDA :ELEN
STA RETLEN
*
** RESTORE RETURN ADDRESS
*
@ -163,13 +240,25 @@ AGET82
LDA RETADR
PHA
*
LDA RETLEN
LDY ADDR1
LDX ADDR1+1
RTS
*
** DATA
*
:XIDX DS 2
:YIDX DS 2
:XLEN DS 1
:YLEN DS 1
:PROD DS 4
:MLIER DS 2
:MCAND DS 2
:ELEN DS 1
*
:E_SID ASC "AGET82 (GET82 MACRO)",00
:E_DUMP ASC ":XIDX(2) :YIDX(2) :XLEN(1) :YLEN(1)"
ASC ":PROD(4) :MLIER(2) :MCAND(2) :ELEN(1)",00
:E_XOVF ASC "X-OVERFLOW! X IS > MAXIMUM OR IS 0.",00
:E_YOVF ASC "Y-OVERFLOW! Y IS > MAX OR IS 0.",00
*

157
disks/disk3_arrays/T.AGET82.SUB.MIN Normal file
View File

@ -0,0 +1,157 @@
AGET82
PLA
STA RETADR
PLA
STA RETADR+1
PLA
STA :YIDX
PLA
STA :XIDX
PLA
STA ADDR1
PLA
STA ADDR1+1
DEC :XIDX
DEC :YIDX
LDY #2
LDA (ADDR1),Y ; ELEMENT LENGTH
STA :MCAND ; ELEMENT LENGTH
STA :ELEN
DEY
LDA (ADDR1),Y ; Y LENGTH
STA :YLEN
DEY
LDA (ADDR1),Y ; X LENGTH
STA :XLEN
LDA #0
STA :MCAND+1
LDA ERRCTRL
CMP #1
BEQ :CHKERR
JMP :ERREND
:CHKERR
LDA :XIDX ; IF X > MAX LEN
CLC
ADC #1
CMP :XLEN
BCS :XOVF
JMP :ERRCONT1
:XOVF
_ERR :E_SID;:E_XOVF;:E_DUMP;:XIDX;#15
:ERRCONT1
LDA :YIDX ; IF Y > MAX LEN
CLC
ADC #1
CMP :YLEN
BCS :YOVF
JMP :ERRCONT2
:YOVF
_ERR :E_SID;:E_YOVF;:E_DUMP;:XIDX;#15
:ERRCONT2
LDA :XIDX ; IF INDEX IS 0, ERR
CMP #255
BEQ :XOVF
:ERRCONT3
LDA :YIDX
CMP #255
BEQ :YOVF
:ERREND
LDA #0
TAY
STY SCRATCH
BEQ :ENTLP
:DOADD
CLC
ADC :YIDX
TAX
TYA
ADC SCRATCH
TAY
TXA
:LP
ASL :YIDX
ROL SCRATCH
:ENTLP
LSR :YLEN
BCS :DOADD
BNE :LP
STX :MLIER
STY :MLIER+1
CLC
LDA :MLIER
ADC :XIDX
STA :MLIER
BCC :CONTADD
LDA :MLIER+1
ADC #1
STA :MLIER+1
:CONTADD
LDA #0
STA :PROD+2
STA :PROD+3
LDX #$10
:SHIFTR LSR :MLIER+1
ROR :MLIER
BCC :ROTR
LDA :PROD+2
CLC
ADC :MCAND
STA :PROD+2
LDA :PROD+3
ADC :MCAND+1
:ROTR
ROR
STA :PROD+3
ROR :PROD+2
ROR :PROD+1
ROR :PROD
DEX
BNE :SHIFTR
CLC
INC :PROD ; INCREASE BY 3
INC :PROD
INC :PROD
BCC :NOCAR
INC :PROD+1
:NOCAR
CLC
LDA :PROD
ADC ADDR1
STA :PROD
LDA :PROD+1
ADC ADDR1+1
STA :PROD+1
LDY :PROD
LDX :PROD+1
STY ADDR1
STX ADDR1+1
LDY #0
:RLP
LDA (ADDR1),Y
STA RETURN,Y
INY
CPY :ELEN
BNE :RLP
LDA :ELEN
STA RETLEN
LDA RETADR+1
PHA
LDA RETADR
PHA
LDA RETLEN
LDY ADDR1
LDX ADDR1+1
RTS
:XIDX DS 2
:YIDX DS 2
:XLEN DS 1
:YLEN DS 1
:PROD DS 4
:MLIER DS 2
:MCAND DS 2
:ELEN DS 1
:E_SID ASC "AGET82 (GET82 MACRO)",00
:E_DUMP ASC ":XIDX(2) :YIDX(2) :XLEN(1) :YLEN(1)"
ASC ":PROD(4) :MLIER(2) :MCAND(2) :ELEN(1)",00
:E_XOVF ASC "X-OVERFLOW! X IS > MAXIMUM OR IS 0.",00
:E_YOVF ASC "Y-OVERFLOW! Y IS > MAX OR IS 0.",00

46
disks/disk3_arrays/T.APUT81.MIN
View File

@ -1,46 +0,0 @@
APUT81
PLA
STA :RETADR
PLA
STA :RETADR+1
PLA
STA :AIDX
PLA
STA ADDR4
PLA
STA ADDR4+1
PLA
STA ADDR3
PLA
STA ADDR3+1
LDA ADDR4+1
PHA
LDA ADDR4
PHA
LDA :AIDX
PHA
JSR AGET81
STY ADDR2
STX ADDR2+1
LDY #1
LDA (ADDR4),Y
STA :ESIZE
LDY #0
:LP
LDA (ADDR3),Y
STA (ADDR2),Y
INY
CPY :ESIZE
BNE :LP
LDA :RETADR+1
PHA
LDA :RETADR
PHA
LDX ADDR2+1
LDY ADDR2
LDA :ESIZE
RTS
:RETADR DS 2
:ESIZE DS 1
:ASIZE DS 1
:AIDX DS 1

123
disks/disk3_arrays/T.APUT81 → disks/disk3_arrays/T.APUT81.SUB
View File

@ -64,6 +64,9 @@ APUT81
*
PLA
STA :AIDX
STA :IDX
DEC :AIDX
DEC :IDX
PLA
STA ADDR4 ; ARRAY ADDRESS; USES ADDR4
; BECAUSE CALL TO AGET81 USES
@ -76,30 +79,110 @@ APUT81
PLA
STA ADDR3+1
*
LDA ADDR4+1
PHA
LDA ADDR4
PHA
LDA :AIDX
PHA
JSR AGET81 ; GET MEMORY POS OF ELEM
STY ADDR2
STX ADDR2+1
*
** GET ARRAY'S ELEMENT SIZE
** GET ARRAY'S SIZE, ELEMENT SIZE
*
LDY #0
LDA (ADDR4),Y
STA :ASIZE
LDY #1
LDA (ADDR4),Y
STA :ESIZE
LDY #0
STA :ESIZEBAK
*
** COPY FROM ADDR1 TO ADDR2
********************************
*
* ERROR CONTROL
*
********************************
*
LDA ERRCTRL
CMP #1
BEQ :CHKERR
JMP :ERREND
:CHKERR
LDA :IDX ; IF IDX > ARRAY LENGTH
CLC
ADC #1
CMP :ASIZE
BCS :OVF
JMP :CHKCONT
:OVF
_ERR :E_SID;:E_OVF1;:E_DUMP;:ESIZE;#9
:CHKCONT
LDA :IDX
CMP #255 ; NO ZERO INDEX
BEQ :UNF ; UNDERFLOW
JMP :ERREND
:UNF
_ERR :E_SID;:E_UNF;:E_DUMP;:ESIZE;#9
*
********************************
*
:ERREND
*
********************************
*
** FIRST, MUL INDEX BY ELEM SIZE, THEN ADD
** TWO TO GET THE ELEMENT ADDRESS.
*
LDY #0
LDA #0
STY SCRATCH
STY SCRATCH+1
BEQ :ENTLPA
:DOADD
CLC
ADC :AIDX
TAX
TYA
ADC SCRATCH
TAY
TXA
:LPA
ASL :AIDX
ROL SCRATCH
:ENTLPA
LSR :ESIZE
BCS :DOADD
BNE :LPA
*
** STORE INDEX VALUE
*
STX :IDX
STY :IDX+1
*
** NOW ADD TWO TO RESULT
*
CLC
LDA #2
ADC :IDX
STA :RES
LDA #0
ADC :IDX+1
STA :RES+1
*
** NOW ADD RESULT TO THE BASE ARRAY ADDRESS
** TO GET THE ELEMENT ADDRESS
*
CLC
LDA :RES
ADC ADDR4
STA :RES
LDA :RES+1
ADC ADDR4+1
STA :RES+1
*
STA ADDR2+1
LDA :RES
STA ADDR2
*
** COPY FROM SRC ADDR3 TO ELEMENT LOCATION ADDR
*
:LP
LDA (ADDR3),Y
STA (ADDR2),Y
INY
CPY :ESIZE
CPY :ESIZEBAK
BNE :LP
*
** RESTORE RETURN ADDRESS
@ -115,13 +198,21 @@ APUT81
LDX ADDR2+1
LDY ADDR2
LDA :ESIZE
*
RTS
*
** DATA
*
:RETADR DS 2
:ESIZE DS 1
:ESIZEBAK DS 1
:ASIZE DS 1
:AIDX DS 1
:AIDX DS 2
:IDX DS 2
:RES DS 2
*
:E_SID ASC "APUT81 (PUT81 MACRO)",00
:E_DUMP ASC "DUMPING :ESIZE(1) :ESIZEBAK(1) :ASIZE(1)"
ASC ":AIDX(2) :IDX(2) :RES(2)",00
:E_OVF1 ASC "OVERFLOW! INDEX HIGHER THAN ARRAY LENGTH",00
:E_UNF ASC "UNDERFLOW! CANNOT USE A ZERO INDEX",00
*

112
disks/disk3_arrays/T.APUT81.SUB.MIN Normal file
View File

@ -0,0 +1,112 @@
APUT81
PLA
STA :RETADR ; LOCAL RETURN ADDRESS STORAGE
PLA ; BECAUSE OF CALLING AGET81
STA :RETADR+1
PLA
STA :AIDX
STA :IDX
DEC :AIDX
DEC :IDX
PLA
STA ADDR4 ; ARRAY ADDRESS; USES ADDR4
; ADDR1
PLA
STA ADDR4+1
PLA
STA ADDR3 ; ADDRESS OF DATA TO BE
PLA
STA ADDR3+1
LDY #0
LDA (ADDR4),Y
STA :ASIZE
LDY #1
LDA (ADDR4),Y
STA :ESIZE
STA :ESIZEBAK
LDA ERRCTRL
CMP #1
BEQ :CHKERR
JMP :ERREND
:CHKERR
LDA :IDX ; IF IDX > ARRAY LENGTH
CLC
ADC #1
CMP :ASIZE
BCS :OVF
JMP :CHKCONT
:OVF
_ERR :E_SID;:E_OVF1;:E_DUMP;:ESIZE;#9
:CHKCONT
LDA :IDX
CMP #255 ; NO ZERO INDEX
BEQ :UNF ; UNDERFLOW
JMP :ERREND
:UNF
_ERR :E_SID;:E_UNF;:E_DUMP;:ESIZE;#9
:ERREND
LDY #0
LDA #0
STY SCRATCH
STY SCRATCH+1
BEQ :ENTLPA
:DOADD
CLC
ADC :AIDX
TAX
TYA
ADC SCRATCH
TAY
TXA
:LPA
ASL :AIDX
ROL SCRATCH
:ENTLPA
LSR :ESIZE
BCS :DOADD
BNE :LPA
STX :IDX
STY :IDX+1
CLC
LDA #2
ADC :IDX
STA :RES
LDA #0
ADC :IDX+1
STA :RES+1
CLC
LDA :RES
ADC ADDR4
STA :RES
LDA :RES+1
ADC ADDR4+1
STA :RES+1
STA ADDR2+1
LDA :RES
STA ADDR2
:LP
LDA (ADDR3),Y
STA (ADDR2),Y
INY
CPY :ESIZEBAK
BNE :LP
LDA :RETADR+1
PHA
LDA :RETADR
PHA
LDX ADDR2+1
LDY ADDR2
LDA :ESIZE
RTS
:RETADR DS 2
:ESIZE DS 1
:ESIZEBAK DS 1
:ASIZE DS 1
:AIDX DS 2
:IDX DS 2
:RES DS 2
:E_SID ASC "APUT81 (PUT81 MACRO)",00
:E_DUMP ASC "DUMPING :ESIZE(1) :ESIZEBAK(1) :ASIZE(1)"
ASC ":AIDX(2) :IDX(2) :RES(2)",00
:E_OVF1 ASC "OVERFLOW! INDEX HIGHER THAN ARRAY LENGTH",00
:E_UNF ASC "UNDERFLOW! CANNOT USE A ZERO INDEX",00

133
disks/disk3_arrays/T.APUT82
View File

@ -1,133 +0,0 @@
*
*``````````````````````````````*
* APUT82 : PUT DATA INTO ELEM *
*- -*
* THIS PUTS DATA FROM ONE ADDR *
* INTO THE ADDRESS OF AN ARRAY *
* WITH THE INDEX OF [:XIDX], *
* [:YIDX]. *
*- -*
* CLOBBERS: *
* *
* FLAGS: ????---- REG: AXYM *
*- -*
* CYCLES: ??? *
* SIZE: *
*- -*
* USAGE: *
* *
* LDA #>$300 ; SOURCE DATA *
* PHA *
* LDA #<$300 *
* PHA *
* LDA #>$3A0 ; DEST ARRAY *
* PHA *
* LDA #<$3A0 *
* PHA *
* LDA #2 ; ELEM X INDEX *
* PHA *
* LDA #3 ; ELEM Y INDEX *
* PHA *
* JSR APUT82 *
*- -*
* ENTRY *
* *
* TOP OF STACK *
* *
* LOW BYTE OF RETURN ADDRESS *
* HI BYTE OF RETURN ADDRESS *
* ELEMENT Y INDEX *
* ELEMENT X INDEX *
* LOW BYTE OF DESTINATION ADDR *
* HI BYTE OF DESTINATION ADDR *
* LO BYTE OF SOURCE ADDRESS *
* HI BYTE OF SOURCE ADDRESS *
*- -*
* EXIT *
* *
* TOP OF STACK *
* *
* LOW BYTE OF RETURN ADDRESS *
* HI BYTE OF RETURN ADDRESS *
* *
* .Y = LOBYTE ELEMENT ADDRESS *
* .X = HIBYTE ELEMENT ADDRESS *
* .A = ELEMENT BYTE LENGTH *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
APUT82
*
** SAVE RETURN ADDRESS
*
PLA
STA :RETADR ; LOCAL BECAUSE OF
PLA ; CALLING AGET82
STA :RETADR+1
*
** GET PARAMETERS
*
PLA
STA :YIDX ; Y INDEX
PLA
STA :XIDX ; X INDEX
PLA
STA ADDR4 ; ADDRESS OF ARRAY
PLA
STA ADDR4+1
PLA
STA ADDR3 ; ADDRESS OF DATA
PLA ; TO BE COPIED
STA ADDR3+1
*
** NOW RUN AGET82 TO GET PROPER ADDRESS
*
LDA ADDR4+1 ; ARRAY ADDRESS
PHA
LDA ADDR4
PHA
LDA :XIDX ; X INDEX
PHA
LDA :YIDX ; Y INDEX
PHA
JSR AGET82
STY ADDR2 ; STORE ADDRESS OF INDEX
STX ADDR2+1 ; IN ZERO PAGE
*
** GET ARRAY ELEMENT SIZE
*
LDY #2
LDA (ADDR4),Y
STA :ESIZE
LDY #0
*
** COPY FROM SRC ADDR TO DEST ADDR
*
:CLP
LDA (ADDR3),Y
STA (ADDR2),Y
INY
CPY :ESIZE
BNE :CLP
*
** RESTORE RETURN ADDRESS
*
LDA :RETADR+1
PHA
LDA :RETADR
PHA
*
** RETURN ELEMENT ADDRESS AND SIZE
*
LDX ADDR2+1
LDY ADDR2
LDA :ESIZE
*
RTS
*
** DATA
*
:RETADR DS 2
:ESIZE DS 1
:XIDX DS 1
:YIDX DS 1
*

280
disks/disk3_arrays/T.APUT82.SUB Normal file
View File

@ -0,0 +1,280 @@
*
*``````````````````````````````*
* APUT82 : PUT DATA INTO ELEM *
*- -*
* THIS PUTS DATA FROM ONE ADDR *
* INTO THE ADDRESS OF AN ARRAY *
* WITH THE INDEX OF [:XIDX], *
* [:YIDX]. *
*- -*
* CLOBBERS: *
* *
* FLAGS: ????---- REG: AXYM *
*- -*
* CYCLES: ??? *
* SIZE: *
*- -*
* USAGE: *
* *
* LDA #>$300 ; SOURCE DATA *
* PHA *
* LDA #<$300 *
* PHA *
* LDA #>$3A0 ; DEST ARRAY *
* PHA *
* LDA #<$3A0 *
* PHA *
* LDA #2 ; ELEM X INDEX *
* PHA *
* LDA #3 ; ELEM Y INDEX *
* PHA *
* JSR APUT82 *
*- -*
* ENTRY *
* *
* TOP OF STACK *
* *
* LOW BYTE OF RETURN ADDRESS *
* HI BYTE OF RETURN ADDRESS *
* ELEMENT Y INDEX *
* ELEMENT X INDEX *
* LOW BYTE OF DESTINATION ADDR *
* HI BYTE OF DESTINATION ADDR *
* LO BYTE OF SOURCE ADDRESS *
* HI BYTE OF SOURCE ADDRESS *
*- -*
* EXIT *
* *
* TOP OF STACK *
* *
* LOW BYTE OF RETURN ADDRESS *
* HI BYTE OF RETURN ADDRESS *
* *
* .Y = LOBYTE ELEMENT ADDRESS *
* .X = HIBYTE ELEMENT ADDRESS *
* .A = ELEMENT BYTE LENGTH *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
APUT82
*
** SAVE RETURN ADDRESS
*
PLA
STA RETADR
PLA
STA RETADR+1
*
** GET PARAMETERS
*
PLA
STA :YIDX ; Y INDEX
DEC :YIDX
PLA
STA :XIDX ; X INDEX
DEC :XIDX
PLA
STA ADDR4 ; ADDRESS OF ARRAY
PLA
STA ADDR4+1
PLA
STA ADDR3 ; ADDRESS OF DATA
PLA ; TO BE COPIED
STA ADDR3+1
*
** GET ARRAY SIZES
*
LDY #2
LDA (ADDR4),Y
STA :ESIZE
STA :MCAND
LDA #0
STA :MCAND+1
LDY #0
LDA (ADDR4),Y
STA :XLEN
INY
LDA (ADDR4),Y
STA :YLEN
LDY #0
*
********************************
*
* ERROR CONTROL
*
********************************
*
LDA ERRCTRL
CMP #1
BEQ :CHKERR
JMP :ERREND
:CHKERR
LDA :XIDX ; IF X > MAX LEN
CLC
ADC #1
CMP :XLEN
BCS :XOVF
JMP :ERRCONT1
:XOVF
_ERR :E_SID;:E_XOVF;:E_DUMP;:XIDX;#15
:ERRCONT1
LDA :YIDX ; IF Y > MAX LEN
CLC
ADC #1
CMP :YLEN
BCS :YOVF
JMP :ERRCONT2
:YOVF
_ERR :E_SID;:E_YOVF;:E_DUMP;:XIDX;#15
:ERRCONT2
LDA :XIDX ; IF INDEX IS 0, ERR
CMP #255
BEQ :XOVF
:ERRCONT3
LDA :YIDX
CMP #255
BEQ :YOVF
*
********************************
*
:ERREND
*
********************************
*
** MULTIPLY Y-INDEX BY Y-LENGTH
*
LDA #0
TAY
STY SCRATCH
BEQ :ENTLP
*
:DOADD
CLC
ADC :YIDX
TAX
*
TYA
ADC SCRATCH
TAY
TXA
*
:LP
ASL :YIDX
ROL SCRATCH
:ENTLP
LSR :YLEN
BCS :DOADD
BNE :LP
*
STX :MLIER
STY :MLIER+1
*
** NOW ADD X INDEX
*
CLC
LDA :MLIER
ADC :XIDX
STA :MLIER
BCC :CONTADD
LDA :MLIER+1
ADC #1
STA :MLIER+1
:CONTADD
*
** NOW MULTIPLY BY LENGTH OF ELEMENTS
*
LDA #0
STA :PROD+2
STA :PROD+3
LDX #$10
:SHIFTR LSR :MLIER+1
ROR :MLIER
BCC :ROTR
LDA :PROD+2
CLC
ADC :MCAND
STA :PROD+2
LDA :PROD+3
ADC :MCAND+1
:ROTR
ROR
STA :PROD+3
ROR :PROD+2
ROR :PROD+1
ROR :PROD
DEX
BNE :SHIFTR
*
CLC
INC :PROD ; INCREASE BY 3
INC :PROD
INC :PROD
BCC :NOCAR
INC :PROD+1
:NOCAR
*
** NOW ADD BASE ADDRESS OF ARRAY TO GET
** THE ADDRESS OF THE INDEX VALUE
*
CLC
LDA :PROD
ADC ADDR4
STA :PROD
LDA :PROD+1
ADC ADDR4+1
STA :PROD+1
LDA :PROD
*SBC #1
*STA :PROD
*
** RETURN ADDRESS IN Y(LOW) AND X(HIGH)
*
LDY :PROD
LDX :PROD+1
STY ADDR2
STX ADDR2+1
*
LDY #0
LDX #0
*
** COPY FROM SRC ADDR TO DEST ADDR
*
:CLP
LDA (ADDR3),Y
STA (ADDR2),Y
INY
CPY :ESIZE
BNE :CLP
*
** RESTORE RETURN ADDRESS
*
LDA RETADR+1
PHA
LDA RETADR
PHA
*
** RETURN ELEMENT ADDRESS AND SIZE
*
LDX ADDR2+1
LDY ADDR2
LDA :ESIZE
*
RTS
*
** DATA
*
:RETADR DS 2
:ESIZE DS 1
:XIDX DS 1
:YIDX DS 1
:MCAND DS 2
:MLIER DS 2
:PROD DS 4
:XLEN DS 1
:YLEN DS 1
*
:E_SID ASC "AGET82 (GET82 MACRO)",00
:E_DUMP ASC ":XIDX(2) :YIDX(2) :XLEN(1) :YLEN(1)"
ASC ":PROD(4) :MLIER(2) :MCAND(2) :ELEN(1)",00
:E_XOVF ASC "X-OVERFLOW! X IS > MAXIMUM OR IS 0.",00
:E_YOVF ASC "Y-OVERFLOW! Y IS > MAX OR IS 0.",00
*

163
disks/disk3_arrays/T.APUT82.SUB.MIN Normal file
View File

@ -0,0 +1,163 @@
APUT82
PLA
STA RETADR
PLA
STA RETADR+1
PLA
STA :YIDX ; Y INDEX
DEC :YIDX
PLA
STA :XIDX ; X INDEX
DEC :XIDX
PLA
STA ADDR4 ; ADDRESS OF ARRAY
PLA
STA ADDR4+1
PLA
STA ADDR3 ; ADDRESS OF DATA
PLA ; TO BE COPIED
STA ADDR3+1
LDY #2
LDA (ADDR4),Y
STA :ESIZE
STA :MCAND
LDA #0
STA :MCAND+1
LDY #0
LDA (ADDR4),Y
STA :XLEN
INY
LDA (ADDR4),Y
STA :YLEN
LDY #0
LDA ERRCTRL
CMP #1
BEQ :CHKERR
JMP :ERREND
:CHKERR
LDA :XIDX ; IF X > MAX LEN
CLC
ADC #1
CMP :XLEN
BCS :XOVF
JMP :ERRCONT1
:XOVF
_ERR :E_SID;:E_XOVF;:E_DUMP;:XIDX;#15
:ERRCONT1
LDA :YIDX ; IF Y > MAX LEN
CLC
ADC #1
CMP :YLEN
BCS :YOVF
JMP :ERRCONT2
:YOVF
_ERR :E_SID;:E_YOVF;:E_DUMP;:XIDX;#15
:ERRCONT2
LDA :XIDX ; IF INDEX IS 0, ERR
CMP #255
BEQ :XOVF
:ERRCONT3
LDA :YIDX
CMP #255
BEQ :YOVF
:ERREND
LDA #0
TAY
STY SCRATCH
BEQ :ENTLP
:DOADD
CLC
ADC :YIDX
TAX
TYA
ADC SCRATCH
TAY
TXA
:LP
ASL :YIDX
ROL SCRATCH
:ENTLP
LSR :YLEN
BCS :DOADD
BNE :LP
STX :MLIER
STY :MLIER+1
CLC
LDA :MLIER
ADC :XIDX
STA :MLIER
BCC :CONTADD
LDA :MLIER+1
ADC #1
STA :MLIER+1
:CONTADD
LDA #0
STA :PROD+2
STA :PROD+3
LDX #$10
:SHIFTR LSR :MLIER+1
ROR :MLIER
BCC :ROTR
LDA :PROD+2
CLC
ADC :MCAND
STA :PROD+2
LDA :PROD+3
ADC :MCAND+1
:ROTR
ROR
STA :PROD+3
ROR :PROD+2
ROR :PROD+1
ROR :PROD
DEX
BNE :SHIFTR
CLC
INC :PROD ; INCREASE BY 3
INC :PROD
INC :PROD
BCC :NOCAR
INC :PROD+1
:NOCAR
CLC
LDA :PROD
ADC ADDR4
STA :PROD
LDA :PROD+1
ADC ADDR4+1
STA :PROD+1
LDA :PROD
LDY :PROD
LDX :PROD+1
STY ADDR2
STX ADDR2+1
LDY #0
LDX #0
:CLP
LDA (ADDR3),Y
STA (ADDR2),Y
INY
CPY :ESIZE
BNE :CLP
LDA RETADR+1
PHA
LDA RETADR
PHA
LDX ADDR2+1
LDY ADDR2
LDA :ESIZE
RTS
:RETADR DS 2
:ESIZE DS 1
:XIDX DS 1
:YIDX DS 1
:MCAND DS 2
:MLIER DS 2
:PROD DS 4
:XLEN DS 1
:YLEN DS 1
:E_SID ASC "AGET82 (GET82 MACRO)",00
:E_DUMP ASC ":XIDX(2) :YIDX(2) :XLEN(1) :YLEN(1)"
ASC ":PROD(4) :MLIER(2) :MCAND(2) :ELEN(1)",00
:E_XOVF ASC "X-OVERFLOW! X IS > MAXIMUM OR IS 0.",00
:E_YOVF ASC "Y-OVERFLOW! Y IS > MAX OR IS 0.",00

379
disks/disk3_arrays/T.ARRAYS.DEMO
View File

@ -3,9 +3,9 @@
* *
* -< ARRAYS DEMO >- *
* *
* VERSION 00.02.00 *
* VERSION 00.03.00 *
* *
* 12-DEC-2018 *
* 15-JAN-2019 *
* *
********************************
* *
@ -18,6 +18,7 @@
*
CYC AVE
EXP ONLY
TR ON
DSK ARRAYS.DEMO
OBJ $BFE0
ORG $6000
@ -26,9 +27,10 @@
* TOP INCLUDES (HOOKS,MACROS) *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
PUT REQUIRED.HOOKS
USE REQUIRED.MAC
USE ARRAYS.MAC
PUT REQUIRED.VARS
PUT REQUIRED.HOOKS.MIN
USE REQUIRED.MAC.MIN
USE ARRAYS.MAC.MIN
PUT ARRAYS.HOOKS
*
*``````````````````````````````*
@ -42,249 +44,156 @@ ARRAY2 EQU $4000
** LOCATION AND SETS UP THE DATA CONFIGURATION
** FOR A 1D ARRAY (ARRAY LENGTH, ELEMENT LENGTH, DATA)
*
** MACRO: DIM81 ADDRESS;ARRAY_SIZE;ELEMENT_LENGTH
*
LDA #>ARRAY1 ; HIGH LOCATION FOR ARRAY
PHA
LDA #<ARRAY1 ; LOW LOCATION
PHA
LDA #06 ; ARRAY LENGTH
PHA
LDA #2 ; ELEMENT LENGTH
PHA
JSR ADIM81
*
** NOW CHECK $300 TO SEE RESULT
*
JSR __P
HEX 8D8D
ASC "1-DIMENSIONAL ARRAY AFTER INITIALIZING"
HEX 8D8D
ASC " "
ASC "0 1 2 3 4 5 "
HEX 8D00
LDA #>$300
PHA
LDA #<$300
PHA
LDA #14 ; ARRAY LENGTH + 2
PHA
JSR __DUMP
JSR __W
** MACRO: DIM81 ADDRESS;ARRAY_SIZE;ELEMENT_LENGTH;FILL_VAL
*
** NOTE THAT INDEXING STARTS AT 0, SO AN ARRAY
** OF TEN ELEMENTS WOULD BE LISTED AS 0..9
*
** APUT81 COPIES DATA FROM ONE SPECIFIED LOCATION
** TO THE ELEMENT INDEXED IN AN ARRAY AT ANOTHER
** LOCATION.
_PRNT " ",8D8D
_PRNT "THE DIM81 MACRO SIMPLY SETS",8D
_PRNT "UP A ONE-DIMENSIONAL ARRAY OF",8D
_PRNT "THE GIVEN SIZE WITH ELEMENTS OF",8D
_PRNT "A GIVEN LENGTH.",8D8D
_PRNT "DIM81 ARRAY1;#10;#1;#$AA RETURNS:",8D8D
DIM81 ARRAY1;#10;#1;#$AA
_DUMP ARRAY1;#2
_DUMP ARRAY1+2;#5
_DUMP ARRAY1+7;#5
_PRNT " ",8D8D
_WAIT
*
*** MACRO: PUT81 $SRC_ADDR;ARRAY_ADDR;INDEX
** PUT81 PUTS THE VALUE AT A SPECIFIED ADDRESS
** INTO THE ARRAY AT THE SPECIFIED INDEX.
*
LDA #$44
STA ARRAY2
LDA #$55
STA ARRAY2+1
LDA #>ARRAY2 ; ADDRESS TO COPY
PHA
LDA #<ARRAY2
PHA
LDA #>ARRAY1 ; ARRAY ADDRESS
PHA
LDA #<ARRAY1
PHA
LDA #2
PHA ; INDEX
JSR APUT81
JSR __P
HEX 8D8D8D
ASC "AFTER PUTTING #4455 AT INDEX 2"
HEX 8D00
LDA #>ARRAY1
PHA
LDA #<ARRAY1
PHA
LDA #14
PHA
JSR __DUMP
JSR __W
** MACRO: PUT81 SRC_ADDR;DEST_ARRAY;INDEX
*
** AGET81 RETURNS THE MEMORY ADDRESS WHERE
** AN ELEMENT AT THE SPECIFIED INDEX IN
** Y (LOW) AND X (HIGH), AS WELL AS COPIES
** THAT ELEMENT TO THE [RETURN] LOCATION
_PRNT "THE PUT81 MACRO PUTS THE VALUE FOUND",8D
_PRNT "AT THE SPECIFIED ADDRESS AND THEN",8D
_PRNT "INSERTS IT INTO THE GIVEN ARRAY AND",8D
_PRNT "INDEX.",8D8D
_PRNT "SO, PUT81 $320;ARRAY1;#1 AND ",8D
_PRNT "PUT81 $321;ARRAY1;#2 RESULTS IN: ",8D8D
LDA #$BB
STA $320
LDA #$CC
STA $321
PUT81 $320;ARRAY1;#1
PUT81 $321;ARRAY1;#2
_DUMP ARRAY1;#2
_DUMP ARRAY1+2;#5
_DUMP ARRAY1+7;#5
_PRNT " ",8D8D
_WAIT
*
*** MACRO: GET81 $ARRAY_ADDRESS;INDEX
_PRNT "NOTE THAT IF YOUR ELEMENT SIZE",8D
_PRNT "IS ONE BYTE.ONLY ONE BYTE IS COPIED;",8D
_PRNT "IF TWO BYTES, THEN TWO ARE COPIED,",8D
_PRNT "AND SO ON. THUS THE FOLLOWING:",8D8D
_PRNT "DIM81 ARRAY2;#10;#2;#$EE",8D
_PRNT "PUT81 $320;ARRAY2;#8",8D8D
_PRNT "RESULTS IN THE FOLLOWING:",8D8D
DIM81 ARRAY2;#10;#2;#$EE
PUT81 $320;ARRAY2;#8
_DUMP ARRAY2;#02
_DUMP ARRAY2+2;#5
_DUMP ARRAY2+7;#5
_DUMP ARRAY2+12;#5
_DUMP ARRAY2+17;#5
_WAIT
_PRNT " ",8D8D
_PRNT "ALSO NOTE THAT BECAUSE ELEMENT SIZES",8D
_PRNT "CAN VARY FROM 1 BYTE TO 255 BYTES,",8D
_PRNT "ALLOWING LITERAL VALUES IS IMPRACTICAL.",8D
_PRNT "THUS, BE SURE TO UTILIZE A PORTION",8D
_PRNT "OF MEM FOR PASSING TO AND FROM ARRAY ",8D
_PRNT "SUBROUTINES. THE [PARAM] ADDR IS GOOD",8D
_PRNT "FOR THIS.",8D8D
_WAIT
*
LDA #>ARRAY1
PHA
LDA #<ARRAY1
PHA
LDA #02 ; INDEX CONTAINS #4455
PHA ; OR "DU" INVERTED
JSR AGET81
_PRNT " ",8D8D
*
JSR __P
HEX 8D8D
ASC "RETURN VALUE OF GET81: "
HEX 00
LDA RETURN
JSR $FDF0 ; COUT1
LDA RETURN+1
JSR $FDF0
JSR __P
HEX 8D00
JSR __W
** GET81 SIMPLY RETRIEVES THE VALUE IN AN
** ARRAY AT THE GIVEN INDEXED ELEMENT IN
** [RETURN].
*
** DIM82 CREATES AN 8BIT, 2D ARRAY AT THE
** SPECIFIED LOCATION WITH THE LENGTH AND
** HEIGHT PASSED VIA THE STACK
** MACRO: GET81 ARRAY_ADDR;INDEX
*
** MACRO: DIM82 $ARRAY_ADDR;ROWS;COLUMNS;ELEMENT_LENGTH
_PRNT "THE GET81 MACRO GETS THE VALUE HELD",8D
_PRNT "IN THE GIVEN ELEMENT IN THE GIVEN",8D
_PRNT "ARRAY. THUS",8D8D
_PRNT "GET81 ARRAY2;#8 RETURNS:",8D8D
GET81 ARRAY2;#8
_DUMP RETURN;RETLEN
_PRNT " ",8D8D
_WAIT
*
LDA #>ARRAY2
PHA
LDA #<ARRAY2 ; ARRAY ADDRESS
PHA
LDA #4 ; X-DIMENSION
PHA
LDA #4 ; Y-DIMESION
PHA
LDA #1 ; ELEMENT SIZE
PHA
JSR ADIM82
** DIM82 CREATES A 2-DIMENSIONAL ARRAY WITH THE
** SPECIFIED ELEMENT LENGTH AND X,Y DIMENSIONS
*
JSR __P
HEX 8D8D
ASC "2-DIMENSIONAL ARRAY, FIRST INITIALIZED"
HEX 8D
HEX 00
LDA #>ARRAY2
PHA
LDA #<ARRAY2
PHA
LDA #3
PHA
JSR __DUMP
LDA #>ARRAY2+3
PHA
LDA #<ARRAY2+3
PHA
LDA #4
PHA
JSR __DUMP
LDA #>ARRAY2+7
PHA
LDA #<ARRAY2+7
PHA
LDA #4
PHA
JSR __DUMP
LDA #>ARRAY2+11
PHA
LDA #<ARRAY2+11
PHA
LDA #4
PHA
JSR __DUMP
LDA #>ARRAY2+15
PHA
LDA #<ARRAY2+15
PHA
LDA #4
PHA
JSR __DUMP
JSR __W
** MACRO: DIM82 ARRAY_ADDR;X_DIM;Y_DIM;ELEM_LENGTH
*
** APUT82 PUTS THE DATA STORED IN ONE LOCATION
** INTO THE ARRAY AT THE SPECIFIED INDEX X,Y.
DIM82 ARRAY2;#10;#10;#1;#$2D
_PRNT "DIM82 CREATES AN ARRAY LIKE DIM81,",8D
_PRNT "BUT IN 2-DIMENSIONS INSTEAD OF ONE.",8D8D
_PRNT "THUS DIM82 ARRAY2;#10;#10;#1;#$2D RETURNS: ",8D8D
_DUMP ARRAY2;#03
_DUMP ARRAY2+03;#10
_DUMP ARRAY2+13;#10
_DUMP ARRAY2+23;#10
_DUMP ARRAY2+33;#10
_DUMP ARRAY2+43;#10
_DUMP ARRAY2+53;#10
_DUMP ARRAY2+63;#10
_DUMP ARRAY2+73;#10
_DUMP ARRAY2+83;#10
_DUMP ARRAY2+93;#10
_PRNT " ",8D8D
_WAIT
*
** MACRO: PUT82 SRC_ADDR;ARRAY_ADDR;ROW_INDEX;COLUMN_INDEX
** THE PUT82 MACRO MIRRORS PUT81, BUT IN 2 DIMENSIONS.
** IN SHORT, IT SIMPLY PUTS THE STRING OF BYTES
** FOUND AT SOURCE_ADDR THAT CORRELATE TO THE ARRAY'S
** ELEMENT LENGTH INTO THE SPECIFIED X,Y INDEX.
*
LDA #180
STA ARRAY1
LDA #>ARRAY1 ; SRC
PHA
LDA #<ARRAY1
PHA
LDA #>ARRAY2 ; DEST
PHA
LDA #<ARRAY2
PHA
LDA #2 ; X INDEX
PHA
LDA #3
PHA ; Y INDEX
JSR APUT82
** MACRO: PUT82 SOURCE_ADDR;ARRAY_ADDR;X_INDEX;Y_INDEX
*
JSR __P
HEX 8D8D
ASC "2D ARRAY AFTER PUTTING '04' AT LOCATION 2,3"
HEX 8D
HEX 00
LDA #>ARRAY2
PHA
LDA #<ARRAY2
PHA
LDA #3
PHA
JSR __DUMP
LDA #>ARRAY2+3
PHA
LDA #<ARRAY2+3
PHA
LDA #4
PHA
JSR __DUMP
LDA #>ARRAY2+7
PHA
LDA #<ARRAY2+7
PHA
LDA #4
PHA
JSR __DUMP
LDA #>ARRAY2+11
PHA
LDA #<ARRAY2+11
PHA
LDA #4
PHA
JSR __DUMP
LDA #>ARRAY2+15
PHA
LDA #<ARRAY2+15
PHA
LDA #4
PHA
JSR __DUMP
JSR __W
_PRNT "PUT82 ACTS LIKE PUT81, BUT IN TWO",8D
_PRNT "DIMENSIONS. ",8D8D
_PRNT "SO: PUT82 $320;ARRAY2;#1;#5 RETURNS",8D8D
LDA #$0F
STA $320
LDA #$FF
STA $321
PUT82 $320;ARRAY2;#01;#05
_DUMP ARRAY2;#03
_DUMP ARRAY2+03;#10
_DUMP ARRAY2+13;#10
_DUMP ARRAY2+23;#10
_DUMP ARRAY2+33;#10
_DUMP ARRAY2+43;#10
_DUMP ARRAY2+53;#10
_DUMP ARRAY2+63;#10
_DUMP ARRAY2+73;#10
_DUMP ARRAY2+83;#10
_DUMP ARRAY2+93;#10
_PRNT " ",8D8D
_WAIT
*
** AGET82 GETS THE MEMORY LOCATION OF THE ELEMENT
** STORED AT INDEX X,Y IN THE GIVEN ARRAYS AND
** RETURNS IT IN Y (LOW) AND X (HIGH); DATA
** IN ELEMENT IS ALSO COPIED TO [RETURN]
** FINALLY, GET82 GETS THE VALUE AT A GIVEN X,Y
** INDEX AND PLACES IT IN [RETURN] WITH THE
** ELEMENT LENGTH IN [RETLEN].
*
** MACRO: GET82 $ARRAY_ADDR;ROW_INDEX;COLUMN_INDEX
** MACRO: GET82 ARRAY_ADDR;X_INDEX;Y_INDEX
*
LDA #>ARRAY2
PHA
LDA #<ARRAY2
PHA
LDA #2 ; X INDEX
PHA
LDA #3 ; Y INDEX
PHA
JSR AGET82
_PRNT "LIKEWISE, GET82 ACTS LIKE GET81,",8D
_PRNT "BUT IN TWO DIMENSIONS. ",8D8D
_PRNT "THUS: GET82 ARRAY2;#1;#5 RETURNS:",8D8D
GET82 ARRAY2;#1;#5
_DUMP RETURN;RETLEN
_WAIT
*
LDA RETURN
JSR __P
HEX 8D8D
ASC "VALUE AT 2,3 VIA AGET82: "
HEX 00
LDA RETURN
JSR $FDF0
JSR __W
_PRNT " ",8D8D
_PRNT "FIN.",8D8D8D
*
JMP REENTRY
*
@ -292,7 +201,19 @@ ARRAY2 EQU $4000
* BOTTOM INCLUDES (ROUTINES) *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
PUT ARRAYS81.LIB
PUT ARRAYS82.LIB
PUT REQUIRED.LIB
PUT REQUIRED.LIB.MIN
*
** INDIVIDUAL SUBROUTINE INCLUDES
*
** 8-BIT 1-DIMENSIONAL ARRAY SUBROUTINES
*
PUT ADIM81.SUB.MIN
PUT AGET81.SUB.MIN
PUT APUT81.SUB.MIN
*
** 8-BIT 2-DIMENSIONAL ARRAY SUBROUTINES
*
PUT ADIM82.SUB.MIN
PUT AGET82.SUB.MIN
PUT APUT82.SUB.MIN
*

0
disks/disk3_arrays/T.ARRAYS.HOOKS.MIN Normal file
View File

5
disks/disk3_arrays/T.ARRAYS.MAC
View File

@ -67,6 +67,8 @@ DIM81 MAC
PHA
LDA ]3 ; ELEMENT LENGTH
PHA
LDA ]4
PHA ; FILL VAL
JSR ADIM81
<<<
*
@ -150,6 +152,7 @@ PUT81 MAC
* ]2 = X DIMENSION *
* ]3 = Y DIMENSION *
* ]4 = ELEMENT SIZE *
* ]5 = FILL VALUE *
*- -*
* SAMPLE USAGE: *
* DIM82 $300;#4;#4;#1 *
@ -166,6 +169,8 @@ DIM82 MAC
PHA
LDA ]4 ; ELEMENT LENGTH
PHA
LDA ]5 ; FILL VAL
PHA
JSR ADIM82
<<<
*

76
disks/disk3_arrays/T.ARRAYS.MAC.MIN Normal file
View File

@ -0,0 +1,76 @@
DIM81 MAC
LDA #>]1 ; ARRAY ADDR
PHA
LDA #<]1
PHA
LDA ]2 ; ARRAY LENGTH
PHA
LDA ]3 ; ELEMENT LENGTH
PHA
LDA ]4
PHA ; FILL VAL
JSR ADIM81
<<<
GET81 MAC
LDA #>]1 ; ARRAY ADDR
PHA
LDA #<]1
PHA
LDA ]2 ; ELEM INDEX
PHA
JSR AGET81
<<<
PUT81 MAC
LDA #>]1
PHA ; SRC ADDR
LDA #<]1
PHA
LDA #>]2 ; DEST ARRAY
PHA
LDA #<]2
PHA
LDA ]3 ; DEST INDEX
PHA
JSR APUT81
<<<
DIM82 MAC
LDA #>]1 ; ARRAY ADDR
PHA
LDA #<]1
PHA
LDA ]2 ; X DIM
PHA
LDA ]3 ; Y DIM
PHA
LDA ]4 ; ELEMENT LENGTH
PHA
LDA ]5 ; FILL VAL
PHA
JSR ADIM82
<<<
GET82 MAC
LDA #>]1 ; ARRAY ADDR
PHA
LDA #<]1
PHA
LDA ]2 ; X INDEX
PHA
LDA ]3 ; Y INDEX
PHA
JSR AGET82
<<<
PUT82 MAC
LDA #>]1 ; SRC ADDR
PHA
LDA #<]1
PHA
LDA #>]2 ; ARRAY ADDR
PHA
LDA #<]2
PHA
LDA ]3 ; X INDEX
PHA
LDA ]4 ; Y INDEX
PHA
JSR APUT82
<<<

525
disks/disk3_arrays/T.ARRAYS81.LIB
View File

@ -1,525 +0,0 @@
JMP ARRAYS81X
*
*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*
* *
* ARRAYS81.LIB *
* *
* AUTHOR: NATHAN RIGGS *
* CONTACT: NATHAN.RIGGS@ *
* OUTLOOK.COM *
* *
* VERSION: 0.2.0 *
* DATE: 09-DEC-2018 *
* ASSEMBLER: MERLIN 8 PRO *
* OS: DOS 3.3 *
* LICENSE: APACHE 2.0 *
* *
* THIS IS A STANDARD LIBRARY *
* FOR 1-DIMENSIONAL 8-BIT *
* ARRAY MANIPULATION. ARRAYS *
* ARE PRECEDED BY LENGTH AND *
* INDEXING INFORMATION. *
* *
*------------------------------*
* *
* LIST OF ROUTINES *
* *
* ADIM81 : DIM 8BIT,1D ARRAY *
* AGET81 : GET ARRAY ELEMENT *
* APUT81 : COPY DATA FROM MEM *
* INTO ELEMENT AT *
* SPECIFIED LOCATION *
* *
*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*
*
*``````````````````````````````*
* ADIM81D : INIT 1D ARRAY *
*- -*
* CREATES AN ARRAY OF LENGTH *
* [:ASIZE] WITH ELEMENTS OF *
* LENGTH [:ESIZE] AT MEMORY *
* LOCATION POINTED TO BY *
* [:ALOC]. RETURNS ARRAY START *
* LOCATION IN .A *
*- -*
* FIRST BYTE OF MEMORY USED *
* HOLDS LENGTH OF ARRAY; *
* SECOND BYTE HOLDS LENGTH OF *
* ELEMENTS. *
*- -*
* CLOBBERS: *
* *
* FLAGS: ????---- REG: AXYM *
*- -*
* CYCLES: ??? *
* SIZE: *
*- -*
* USAGE: *
* *
* LDA #>$300 ; ARRAYLOC *
* PHA *
* LDA #<$300 *
* PHA *
* LDA #10 ; ARRAY SIZE *
* PHA *
* LDA #2 ; ELEMENT SIZE *
* PHA *
* JSR DIM81 *
*- -*
* ENTRY *
* *
* TOP OF STACK *
* *
* LOW BYTE OF RETURN ADDRESS *
* HI BYTE OF RETURN ADDRESS *
* ELEMENT SIZE *
* ARRAY SIZE *
* LOW BYTE OF ARRAY ADDRESS *
* HIGH BYTE OF ARRAY ADDRESS *
*- -*
* EXIT *
* *
* TOP OF STACK *
* *
* LOW BYTE OF RETURN ADDRESS *
* HI BYTE OF RETURN ADDRESS *
* *
* .Y = LO BYTE OF ARRAY ADDR *
* .X = HI BYTE OF ARRAY ADDR *
* .A = ARRAY SIZE *
* *
* [RETURN] = TOTAL SIZE OF *
* ARRAY IN BYTES (WORD) *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
ADIM81
*
** FIRST, CLEAR BLOCK OF MEM TO BE USED
** THEN MUL [:ASIZE] BY [:ESIZE], AND ADD 2 TO
** GET TOTAL MEMORY USED BY ARRAY
*
** SAVE RETURN ADDRESS
*
PLA
STA RETADR
PLA
STA RETADR+1
*
** GET PARAMETERS
*
PLA
STA :ESIZE ; ELEMENT SIZE
STA :ESZBAK
PLA
STA :ASIZE ; ARRAY SIZE
STA :ASZBAK
PLA
STA ADDR1
PLA
STA ADDR1+1
LDY #0
LDA #0
STY SCRATCH
BEQ :ENTLP
*
** MULTIPLY [:ASIZE] AND [:ESIZE] TO GET
** TOTAL SIZE OF MEMORY TO CLEAR AND USE
*
:DOADD
CLC
ADC :ASIZE
TAX
*
TYA
ADC SCRATCH
TAY
TXA
*
:LP
ASL :ASIZE
ROL SCRATCH
:ENTLP
LSR :ESIZE
BCS :DOADD
BNE :LP
*
CLC
INX
INX ; INCREASE BY TWO
; TO MAKE ROOM FOR SIZES
BCC :NOINY ; IF .X ROLLS OVER, INC .Y
INY
:NOINY
STX :MSIZE ; LOW BYTE
STY :MSIZE+1 ; HIGH BYTE
*
** NOW CLEAR MEMORY BLOCKS
*
** FILL WHOLE PAGES FIRST
*
LDA #0 ; FILL VALUE
LDX :MSIZE+1
BEQ :PART ; IF NO WHOLE PAGES, JUST PART
LDY #0
:FULL
STA (ADDR1),Y
INY ; NEXT BYTE
BNE :FULL ; LOOP UNTIL PAGE DONE
INC ADDR1+1 ; GO TO NEXT PAGE
DEX
BNE :FULL ; LOOP IF PAGES LEFT
*
** NOW DO REMAINING PARTIAL PAGES
*
:PART
LDX :MSIZE ; PARTIAL PAGE BYTES
BEQ :MFEXIT ; EXIT IF = 0
LDY #0
:PARTLP
STA (ADDR1),Y ; STORE VAL
INY ; INC INDEX
DEX ; DEC COUNTER
BNE :PARTLP ; LOOP UNTIL DONE
:MFEXIT
*
** MEMORY FILL IS DONE
*
** THEN, SET SIZES
*
LDY #0
LDA :ASZBAK
STA (ADDR1),Y
INY
LDA :ESZBAK
STA (ADDR1),Y
*
** RESTORE RETURN ADDRESS
*
LDA RETADR+1
PHA
LDA RETADR
PHA
*
** RETURN POINTER TO STARTING ADDR OF ARRAY
*
LDY ADDR1 ; LOW
LDX ADDR1+1 ; HIGH
LDA :ASZBAK
*
** STORE TOTAL ARRAY SIZE IN BYTES
** IN MEMORY ALLOCATED FOR RETURN VALUES
*
LDA :MSIZE
STA RETURN
LDA :MSIZE+1
STA RETURN+1
LDA #2
STA RETLEN ; 2 BYTE LENGTH
*
RTS
*
** DATA
*
:MSIZE DS 2
:ASIZE DS 1
:ESIZE DS 1
:ASZBAK DS 1
:ESZBAK DS 1
*
*``````````````````````````````*
* AGET81 : GET ARRAY ELEMENT *
* ADDRESS *
*- -*
* GETS THE SPECIFIED ELEMENT *
* OF THE ARRAY AND COPIES IT *
* TO MEMORY DEDICATED TO *
* RETURN VALUES. *
*- -*
* CLOBBERS: *
* *
* FLAGS: ????---- REG: AXYM *
*- -*
* CYCLES: ??? *
* SIZE: *
*- -*
* USAGE: *
* *
* LDA #>$300 ;HI ARADDR *
* PHA *
* LDA #<$300 ; LOW *
* PHA *
* LDA #5 ; INDEX *
* PHA *
* JSR AGET81 *
*- -*
* ENTRY *
* *
* TOP OF STACK *
* *
* LOW BYTE OF RETURN ADDRESS *
* HI BYTE OF RETURN ADDRESS *
* INDEX OF ELEMENT TO GET *
* ADDRESS OF ARRAY LO BYTE *
* ADDRESS OF ARRAY HI BYTE *
*- -*
* EXIT *
* *
* TOP OF STACK *
* *
* LOW BYTE OF RETURN ADDRESS *
* HI BYTE OF RETURN ADDRESS *
* *
* .Y = LOBYTE OF ELEMENT ADDR *
* .X = HIBYTE OF ELEMENT ADDR *
* .A = LENGTH OF RETURN VAL *
* *
* [RETURN] VALUE FOUND AT *
* SPECIFIED INDEX *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
AGET81
*
** SAVE RETURN ADDRESS
*
PLA
STA RETADR
PLA
STA RETADR+1
*
** GET PARAMETERS
*
PLA
STA :IDX
PLA
STA ADDR1
PLA
STA ADDR1+1
LDA #0
STA :IDX+1
*
** GET ELEMENT SIZE
*
LDY #1 ; ELEMENT SIZE LOC
LDA (ADDR1),Y
STA :ESIZE
STA RETLEN ; LENGTH OF RETURN VALUE
*
** FIRST, MUL INDEX BY ELEMENT SIZE,
** THEN ADD TWO TO GET THE PROPER ADDRESS.
*
LDY #0
LDA #0
TAY
STY SCRATCH
BEQ :ENTLP
*
:DOADD
CLC
ADC :IDX
TAX
TYA
ADC SCRATCH
TAY
TXA
:LP
ASL :IDX
ROL SCRATCH
:ENTLP
LSR :ESIZE
BCS :DOADD
BNE :LP
*
** INDEX STORED AT X (LOW) AND Y (HIGH)
*
STX :IDX
STY :IDX+1
*
** ADD 2 TO INDEX
*
CLC
LDA #2
ADC :IDX
STA :RES
LDA #0
ADC :IDX+1
STA :RES+1
*
** NOW ADD THAT TO BASE ARRAY ADDRESS
** TO GET ADDRESS OF INDEX VALUE
*
CLC
LDA :RES
ADC ADDR1 ; LOW OF ARRAY ADDRESS
STA :RES
LDA :RES+1
ADC ADDR1+1
STA :RES+1
*
** NOW MOVE SPECIFIED ELEMENT DATA TO THE
** MEMORY LOCATION DEDICATED TO RETURN VALUES
*
LDY #0
LDA :RES
STA ADDR1
LDA :RES+1
STA ADDR1+1
:LDLOOP
LDA (ADDR1),Y
STA RETURN,Y
INY
CPY RETLEN
BCC :LDLOOP ; IF .Y <= RETLEN
BEQ :LDLOOP ; KEEP LOOPING
*
*
** RESTORE RETURN ADDRESS
*
LDA RETADR+1
PHA
LDA RETADR
PHA
*
** ADDRESS TO ARRAY ELEMENT IS STORED
** IN .Y (LOW BYTE), .X (HIGH BYTE)
*
** LENGTH OF RETURN VALUE IS STORED IN .A
*
LDY :RES
LDX :RES+1
LDA RETLEN
RTS
*
** DATA
*
:RES DS 2
:IDX DS 2
:ESIZE DS 1
*
*``````````````````````````````*
* APUT81 : PUT DATA INTO ARRAY *
* ELEMENT *
*- -*
* COPIES FROM SOURCE LOCATION *
* AND PUTS IT IN MEMLOC FOR *
* DESIRED ELEMENT. *
*- -*
* CLOBBERS: *
* *
* FLAGS: ????---- REG: AXYM *
*- -*
* CYCLES: ??? *
* SIZE: *
*- -*
* USAGE: *
* *
* LDA #>$300 ; SRC ADDR *
* PHA *
* LDA #<$300 *
* PHA *
* LDA #>$300 ;DEST ADDR *
* PHA *
* STA #<$300 *
* PHA *
* LDA #5 ; INDEX *
* PHA *
*- -*
* ENTRY *
* *
* TOP OF STACK *
* *
* LOW BYTE OF RETURN ADDRESS *
* HI BYTE OF RETURN ADDRESS *
* INDEX OF PUT ELEMENT *
* LOW BYTE OF DESTINATION ADDR *
* HI BYTE OF DESTINATION ADDR *
* LO BYTE OF SOURCE ADDRESS *
* HI BYTE OF SOURCE ADDRESS *
*- -*
* EXIT *
* *
* TOP OF STACK *
* *
* LOW BYTE OF RETURN ADDRESS *
* HI BYTE OF RETURN ADDRESS *
* *
* .Y = LOBYTE OF ELEMENT ADDR *
* .X = HIBYTE OF ELEMENT ADDR *
* .A = BYTE LENGTH OF ELEMENT *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
APUT81
*
** SAVE RETURN ADDRESS
*
PLA
STA :RETADR ; LOCAL RETURN ADDRESS STORAGE
PLA ; BECAUSE OF CALLING AGET81
STA :RETADR+1
*
** GET PARAMETERS
*
PLA
STA :AIDX
PLA
STA ADDR4 ; ARRAY ADDRESS; USES ADDR4
; BECAUSE CALL TO AGET81 USES
; ADDR1
PLA
STA ADDR4+1
PLA
STA ADDR3 ; ADDRESS OF DATA TO BE
; COPIED TO ELEMENT
PLA
STA ADDR3+1
*
LDA ADDR4+1
PHA
LDA ADDR4
PHA
LDA :AIDX
PHA
JSR AGET81 ; GET MEMORY POS OF ELEM
STY ADDR2
STX ADDR2+1
*
** GET ARRAY'S ELEMENT SIZE
*
LDY #1
LDA (ADDR4),Y
STA :ESIZE
LDY #0
*
** COPY FROM ADDR1 TO ADDR2
*
:LP
LDA (ADDR3),Y
STA (ADDR2),Y
INY
CPY :ESIZE
BNE :LP
*
** RESTORE RETURN ADDRESS
*
LDA :RETADR+1
PHA
LDA :RETADR
PHA
*
** RETURN ELEMENT ADDRESS AND SIZE
** IN REGISTERS
*
LDX ADDR2+1
LDY ADDR2
LDA :ESIZE
*
RTS
*
** DATA
*
:RETADR DS 2
:ESIZE DS 1
:ASIZE DS 1
:AIDX DS 1
*
ARRAYS81X
*

216
disks/disk3_arrays/T.ARRAYS81.MIN
View File

@ -1,216 +0,0 @@
JMP ARRAYS81X
SKP 10
ADIM81
PLA
STA RETADR
PLA
STA RETADR+1
PLA
STA :ESIZE
STA :ESZBAK
PLA
STA :ASIZE
STA :ASZBAK
PLA
STA ADDR1
PLA
STA ADDR1+1
LDY #0
LDA #0
STY SCRATCH
BEQ :ENTLP
:DOADD
CLC
ADC :ASIZE
TAX
TYA
ADC SCRATCH
TAY
TXA
:LP
ASL :ASIZE
ROL SCRATCH
:ENTLP
LSR :ESIZE
BCS :DOADD
BNE :LP
CLC
INX
INX
BCC :NOINY
INY
:NOINY
STX :MSIZE
STY :MSIZE+1
LDA #0
LDX :MSIZE+1
BEQ :PART
LDY #0
:FULL
STA (ADDR1),Y
INY
BNE :FULL
INC ADDR1+1
DEX
BNE :FULL
:PART
LDX :MSIZE
BEQ :MFEXIT
LDY #0
:PARTLP
STA (ADDR1),Y
INY
DEX
BNE :PARTLP
:MFEXIT
LDY #0
LDA :ASZBAK
STA (ADDR1),Y
INY
LDA :ESZBAK
STA (ADDR1),Y
LDA RETADR+1
PHA
LDA RETADR
PHA
LDY ADDR1
LDX ADDR1+1
LDA :ASZBAK
LDA :MSIZE
STA RETURN
LDA :MSIZE+1
STA RETURN+1
LDA #2
STA RETLEN
RTS
:MSIZE DS 2
:ASIZE DS 1
:ESIZE DS 1
:ASZBAK DS 1
:ESZBAK DS 1
SKP 10
AGET81
PLA
STA RETADR
PLA
STA RETADR+1
PLA
STA :IDX
PLA
STA ADDR1
PLA
STA ADDR1+1
LDA #0
STA :IDX+1
LDY #1
LDA (ADDR1),Y
STA :ESIZE
STA RETLEN
LDY #0
LDA #0
TAY
STY SCRATCH
BEQ :ENTLP
:DOADD
CLC
ADC :IDX
TAX
TYA
ADC SCRATCH
TAY
TXA
:LP
ASL :IDX
ROL SCRATCH
:ENTLP
LSR :ESIZE
BCS :DOADD
BNE :LP
STX :IDX
STY :IDX+1
CLC
LDA #2
ADC :IDX
STA :RES
LDA #0
ADC :IDX+1
STA :RES+1
CLC
LDA :RES
ADC ADDR1
STA :RES
LDA :RES+1
ADC ADDR1+1
STA :RES+1
LDY #0
LDA :RES
STA ADDR1
LDA :RES+1
STA ADDR1+1
:LDLOOP
LDA (ADDR1),Y
STA RETURN,Y
INY
CPY RETLEN
BCC :LDLOOP
BEQ :LDLOOP
LDA RETADR+1
PHA
LDA RETADR
PHA
LDY :RES
LDX :RES+1
LDA RETLEN
RTS
:RES DS 2
:IDX DS 2
:ESIZE DS 1
SKP 10
APUT81
PLA
STA :RETADR
PLA
STA :RETADR+1
PLA
STA :AIDX
PLA
STA ADDR4
PLA
STA ADDR4+1
PLA
STA ADDR3
PLA
STA ADDR3+1
LDA ADDR4+1
PHA
LDA ADDR4
PHA
LDA :AIDX
PHA
JSR AGET81
STY ADDR2
STX ADDR2+1
LDY #1
LDA (ADDR4),Y
STA :ESIZE
LDY #0
:LP
LDA (ADDR3),Y
STA (ADDR2),Y
INY
CPY :ESIZE
BNE :LP
LDA :RETADR+1
PHA
LDA :RETADR
PHA
LDX ADDR2+1
LDY ADDR2
LDA :ESIZE
RTS
:RETADR DS 2
:ESIZE DS 1
:ASIZE DS 1
:AIDX DS 1
ARRAYS81X

596
disks/disk3_arrays/T.ARRAYS82.LIB
View File

@ -1,596 +0,0 @@
JMP ARRAYS82X
*
*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*
* *
* ARRAYS82.LIB *
* *
* AUTHOR: NATHAN RIGGS *
* CONTACT: NATHAN.RIGGS@ *
* OUTLOOK.COM *
* *
* VERSION: 0.2.0 *
* DATE: 09-DEC-2018 *
* ASSEMBLER: MERLIN 8 PRO *
* OS: DOS 3.3 *
* LICENSE: APACHE 2.0 *
* *
* THIS IS A STANDARD LIBRARY *
* FOR 8BIT, 2 DIMENSIONAL *
* ARRAY MANIPULATION. ARRAYS *
* ARE PRECEDED BY LENGTH AND *
* INDEXING INFORMATION. *
* *
*------------------------------*
* *
* LIST OF ROUTINES *
* *
* ADIM82 : DIM 2D, 8BIT ARRAY *
* AGET82: GET SPECIFIED INDEX *
* ELEMENT; PUT RETURN *
* APUT82: PUT CONTENTS OF ONE *
* ADDRESS INTO ARRAY *
* AT INDEX X,Y *
* *
*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*
*
*``````````````````````````````*
* ADIM82 : INIT 2D ARRAY *
*- -*
* THIS SIMPLY CREATES A 1D *
* ARRAY WITH THE DIM OF *
* [:AXSIZE] BY [:AYSIZE]. *
*- -*
* FIRST BYTE OF MEMORY USED *
* HOLDS LENGTH OF X (ROWS); *
* SECOND BYTE HOLDS LENGTH OF *
* Y (COLUMNS); THIRD BYTE *
* HOLDS LENGTH OF EACH ELEMENT *
*- -*
* CLOBBERS: *
* *
* FLAGS: ????---- REG: AXYM *
*- -*
* CYCLES: ??? *
* SIZE: *
*- -*
* USAGE: *
* *
* LDA #>$300 ; ARRAY ADDR *
* PHA *
* LDA #<$300 *
* PHA *
* LDA #4 ; X DIMENSION BOUND *
* PHA *
* LDA #4 ; Y DIMENSION BOUND *
* PHA *
* LDA #1 ; ELEMENT BYTESIZE *
* PHA *
* JSR DIM82 *
*- -*
* ENTRY *
* *
* TOP OF STACK *
* *
* LOW BYTE OF RETURN ADDRESS *
* HI BYTE OF RETURN ADDRESS *
* ELEMENT SIZE IN BYTES *
* Y DIMENSION BOUNDARY *
* X DIMENSION BOUNDARY *
* ARRAY ADDRESS, LOW BYTE *
* ARRAY ADDRESS, HIGH BYTE *
*- -*
* EXIT *
* *
* TOP OF STACK *
* *
* LOW BYTE OF RETURN ADDRESS *
* HI BYTE OF RETURN ADDRESS *
* *
* .Y = ARRAY ADDRESS LO BYTE *
* .X = ARRAY ADDRESS HI BYTE *
* .A = ELEMENT SIZE *
* *
* [RETURN] = TOTAL BYTE SIZE *
* OF ARRAY. *
* *
* [RETLEN] = LENGTH IN BYTES *
* OF THE RETURN VALUE. *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
ADIM82
*
** SAVE RETURN ADDRESS
*
PLA
STA RETADR
PLA
STA RETADR+1
*
** GET PARAMETERS
*
PLA
STA :MCAND ; ELEMENT LENGTH
PLA
STA :AYSIZE
STA :AYBAK
PLA
STA :AXSIZE
STA :AXBAK
PLA
STA ADDR1
PLA
STA ADDR1+1
LDA #0
STA :MCAND+1
*
** LOOP THROUGH Y, CLEARING MEMORY
** FOR X BYTES TIMES ELEMENT SIZE,
** MOVING TO END OF LAST CLEAR
** UNTIL FINISHED
*
** MULTIPLY X AND Y
*
LDA #0
TAY
STY SCRATCH
BEQ :ENTLP
*
:DOADD
CLC
ADC :AXSIZE
TAX
*
TYA
ADC SCRATCH
TAY
TXA
*
:LP
ASL :AXSIZE
ROL SCRATCH
:ENTLP
LSR :AYSIZE
BCS :DOADD
BNE :LP
*
STX :MLIER
STY :MLIER+1
*
** NOW MULTIPLY BY LENGTH OF ELEMENTS
*
LDA #0
STA :PROD
STA :PROD+1
STA :PROD+2
STA :PROD+3
LDX #$10
:SHIFTR LSR :MLIER+1
ROR :MLIER
BCC :ROTR
LDA :PROD+2
CLC
ADC :MCAND
STA :PROD+2
LDA :PROD+3
ADC :MCAND+1
:ROTR
ROR
STA :PROD+3
ROR :PROD+2
ROR :PROD+1
ROR :PROD
DEX
BNE :SHIFTR
*
CLC
INC :PROD ; INCREASE BY 3
INC :PROD
INC :PROD
BCC :NOCAR
INC :PROD+1
:NOCAR
*
** NOW CLEAR MEMORY BLOCKS, WHOLE PAGES FIRST
*
LDA #$00 ; FILL VALUE
LDX :PROD+1 ; NOTE THAT THIS WON'T
; GO BEYOND A 16BIT VALUE;
; ANYTHING HIGHER THAN
; 16BITS IS MORE THAN
; THERE IS MEMORY IN A
; STANDARD APPLE ][
BEQ :PART
LDY #0
:FULL
STA (ADDR1),Y
INY
BNE :FULL
INC ADDR1+1
DEX
BNE :FULL ; LOOP UNTIL PAGES DONE
*
** NOW DO REMAINING BYTES
*
:PART
LDX :PROD
BEQ :MFEXIT
LDY #0
:PARTLP
STA (ADDR1),Y
INY
DEX
BNE :PARTLP ; LOOP UNTIL DONE
:MFEXIT
*
** NOW SET SIZES
*
LDY #0
LDA :AXBAK
STA (ADDR1),Y
INY
LDA :AYBAK
STA (ADDR1),Y
INY
LDA :MCAND
STA (ADDR1),Y
*
** RESTORE RETURN ADDRESS
*
LDA RETADR+1
PHA
LDA RETADR
PHA
*
** RETURN POINTER TO STARTING ADDRESS OF ARRAY
** AND STORE TOTAL BYTE SIZE IN RETURN MEM
*
LDY ADDR1
LDX ADDR1+1
LDA :PROD
STA RETURN
LDA :PROD+1
STA RETURN+1
LDA :PROD+2
STA RETURN+2
LDA :PROD+3
STA RETURN+3
LDA #4 ; SIZE OF RETURN
STA RETLEN
LDA :MCAND
*
RTS
*
** DATA
*
:PROD DS 4
:AXSIZE DS 1
:AYSIZE DS 1
:AXBAK DS 1
:AYBAK DS 1
:MLIER DS 2
:MCAND DS 2
*
*``````````````````````````````*
* AGET82 : INIT 2D ARRAY *
*- -*
* THIS GETS THE ADDRESS OF AN *
* ELEMENT AT THE INDEX OF *
* [:XIDX],[:YIDX]. *
*- -*
* CLOBBERS: *
* *
* FLAGS: ????---- REG: AXYM *
*- -*
* CYCLES: ??? *
* SIZE: *
*- -*
* USAGE: *
* *
* LDA #>$300 ; ARRAY ADDR *
* PHA *
* LDA #<$300 *
* PHA *
* LDA #2 ; X INDEX *
* PHA *
* LDA #3 ; Y INDEX *
* PHA *
* JSR AGET82 *
*- -*
* ENTRY *
* *
* TOP OF STACK *
* *
* LOW BYTE OF RETURN ADDRESS *
* HI BYTE OF RETURN ADDRESS *
* Y INDEX OF ELEMENT *
* X INDEX OF ELEMENT *
* LOW BYTE OF ARRAY ADDRESS *
* HIGH BYTE OF ARRAY ADDRESS *
*- -*
* EXIT *
* *
* TOP OF STACK *
* *
* LOW BYTE OF RETURN ADDRESS *
* HI BYTE OF RETURN ADDRESS *
* *
* .Y = LO BYTE OF ELEM ADDR *
* .X = HI BYTE OF ELEM ADDR *
* .A = ELEMENT/RETURN LENGTH *
* *
* [RETURN] = VALUE FOUND AT *
* SPECIFIED INDEX. *
* *
* [RETLEN] = LENGTH IN BYTES *
* OF THE RETURN VALUE. *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
AGET82
*
** SAVE RETURN ADDRESS
*
PLA
STA RETADR
PLA
STA RETADR+1
*
** GET PARAMETERS
*
PLA
STA :YIDX
PLA
STA :XIDX
PLA
STA ADDR1
PLA
STA ADDR1+1
*
LDY #2
LDA (ADDR1),Y ; ELEMENT LENGTH
STA :MCAND ; ELEMENT LENGTH
STA :ELEN
LDA #0
STA :MCAND+1
*
** MULTIPLY X AND Y
*
LDA #0
TAY
STY SCRATCH
BEQ :ENTLP
*
:DOADD
CLC
ADC :XIDX
TAX
*
TYA
ADC SCRATCH
TAY
TXA
*
:LP
ASL :XIDX
ROL SCRATCH
:ENTLP
LSR :YIDX
BCS :DOADD
BNE :LP
*
STX :MLIER
STY :MLIER+1
*
** NOW MULTIPLY BY LENGTH OF ELEMENTS
*
LDA #0
STA :PROD+2
STA :PROD+3
LDX #$10
:SHIFTR LSR :MLIER+1
ROR :MLIER
BCC :ROTR
LDA :PROD+2
CLC
ADC :MCAND
STA :PROD+2
LDA :PROD+3
ADC :MCAND+1
:ROTR
ROR
STA :PROD+3
ROR :PROD+2
ROR :PROD+1
ROR :PROD
DEX
BNE :SHIFTR
*
CLC
INC :PROD ; INCREASE BY 3
INC :PROD
INC :PROD
BCC :NOCAR
INC :PROD+1
:NOCAR
*
** NOW ADD BASE ADDRESS OF ARRAY TO GET
** THE ADDRESS OF THE INDEX VALUE
*
CLC
LDA :PROD
ADC ADDR1
STA :PROD
LDA :PROD+1
ADC ADDR1+1
STA :PROD+1
*
** RETURN ADDRESS IN Y(LOW) AND X(HIGH)
*
LDY :PROD
LDX :PROD+1
STY ADDR1
STX ADDR1+1
LDY #0
:RLP
LDA (ADDR1),Y
STA RETURN,Y
INY
CPY :ELEN
BNE :RLP
LDA :ELEN
STA RETLEN
*
** RESTORE RETURN ADDRESS
*
LDA RETADR+1
PHA
LDA RETADR
PHA
*
LDA RETLEN
LDY ADDR1
LDX ADDR1+1
RTS
*
** DATA
*
:XIDX DS 2
:YIDX DS 2
:PROD DS 4
:MLIER DS 2
:MCAND DS 2
:ELEN DS 1
*
*``````````````````````````````*
* APUT82 : PUT DATA INTO ELEM *
*- -*
* THIS PUTS DATA FROM ONE ADDR *
* INTO THE ADDRESS OF AN ARRAY *
* WITH THE INDEX OF [:XIDX], *
* [:YIDX]. *
*- -*
* CLOBBERS: *
* *
* FLAGS: ????---- REG: AXYM *
*- -*
* CYCLES: ??? *
* SIZE: *
*- -*
* USAGE: *
* *
* LDA #>$300 ; SOURCE DATA *
* PHA *
* LDA #<$300 *
* PHA *
* LDA #>$3A0 ; DEST ARRAY *
* PHA *
* LDA #<$3A0 *
* PHA *
* LDA #2 ; ELEM X INDEX *
* PHA *
* LDA #3 ; ELEM Y INDEX *
* PHA *
* JSR APUT82 *
*- -*
* ENTRY *
* *
* TOP OF STACK *
* *
* LOW BYTE OF RETURN ADDRESS *
* HI BYTE OF RETURN ADDRESS *
* ELEMENT Y INDEX *
* ELEMENT X INDEX *
* LOW BYTE OF DESTINATION ADDR *
* HI BYTE OF DESTINATION ADDR *
* LO BYTE OF SOURCE ADDRESS *
* HI BYTE OF SOURCE ADDRESS *
*- -*
* EXIT *
* *
* TOP OF STACK *
* *
* LOW BYTE OF RETURN ADDRESS *
* HI BYTE OF RETURN ADDRESS *
* *
* .Y = LOBYTE ELEMENT ADDRESS *
* .X = HIBYTE ELEMENT ADDRESS *
* .A = ELEMENT BYTE LENGTH *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
APUT82
*
** SAVE RETURN ADDRESS
*
PLA
STA :RETADR ; LOCAL BECAUSE OF
PLA ; CALLING AGET82
STA :RETADR+1
*
** GET PARAMETERS
*
PLA
STA :YIDX ; Y INDEX
PLA
STA :XIDX ; X INDEX
PLA
STA ADDR4 ; ADDRESS OF ARRAY
PLA
STA ADDR4+1
PLA
STA ADDR3 ; ADDRESS OF DATA
PLA ; TO BE COPIED
STA ADDR3+1
*
** NOW RUN AGET82 TO GET PROPER ADDRESS
*
LDA ADDR4+1 ; ARRAY ADDRESS
PHA
LDA ADDR4
PHA
LDA :XIDX ; X INDEX
PHA
LDA :YIDX ; Y INDEX
PHA
JSR AGET82
STY ADDR2 ; STORE ADDRESS OF INDEX
STX ADDR2+1 ; IN ZERO PAGE
*
** GET ARRAY ELEMENT SIZE
*
LDY #2
LDA (ADDR4),Y
STA :ESIZE
LDY #0
*
** COPY FROM SRC ADDR TO DEST ADDR
*
:CLP
LDA (ADDR3),Y
STA (ADDR2),Y
INY
CPY :ESIZE
BNE :CLP
*
** RESTORE RETURN ADDRESS
*
LDA :RETADR+1
PHA
LDA :RETADR
PHA
*
** RETURN ELEMENT ADDRESS AND SIZE
*
LDX ADDR2+1
LDY ADDR2
LDA :ESIZE
*
RTS
*
** DATA
*
:RETADR DS 2
:ESIZE DS 1
:XIDX DS 1
:YIDX DS 1
*
ARRAYS82X
*

266
disks/disk3_arrays/T.ARRAYS82.MIN
View File

@ -1,266 +0,0 @@
JMP ARRAYS82X
********************************
DIM82
PLA
STA RETADR
PLA
STA RETADR+1
PLA
STA :MCAND
PLA
STA :AYSIZE
STA :AYBAK
PLA
STA :AXSIZE
STA :AXBAK
PLA
STA ADDR1
PLA
STA ADDR1+1
LDA #0
STA :MCAND+1
LDA #0
TAY
STY SCRATCH
BEQ :ENTLP
:DOADD
CLC
ADC :AXSIZE
TAX
TYA
ADC SCRATCH
TAY
TXA
:LP
ASL :AXSIZE
ROL SCRATCH
:ENTLP
LSR :AYSIZE
BCS :DOADD
BNE :LP
STX :MLIER
STY :MLIER+1
LDA #0
STA :PROD
STA :PROD+1
STA :PROD+2
STA :PROD+3
LDX #$10
:SHIFTR LSR :MLIER+1
ROR :MLIER
BCC :ROTR
LDA :PROD+2
CLC
ADC :MCAND
STA :PROD+2
LDA :PROD+3
ADC :MCAND+1
:ROTR
ROR
STA :PROD+3
ROR :PROD+2
ROR :PROD+1
ROR :PROD
DEX
BNE :SHIFTR
CLC
INC :PROD
INC :PROD
INC :PROD
BCC :NOCAR
INC :PROD+1
:NOCAR
LDA #$00
LDX :PROD+1
BEQ :PART
LDY #0
:FULL
STA (ADDR1),Y
INY
BNE :FULL
INC ADDR1+1
DEX
BNE :FULL
:PART
LDX :PROD
BEQ :MFEXIT
LDY #0
:PARTLP
STA (ADDR1),Y
INY
DEX
BNE :PARTLP
:MFEXIT
LDY #0
LDA :AXBAK
STA (ADDR1),Y
INY
LDA :AYBAK
STA (ADDR1),Y
INY
LDA :MCAND
STA (ADDR1),Y
LDA RETADR+1
PHA
LDA RETADR
PHA
LDY ADDR1
LDX ADDR1+1
LDA :PROD
STA RETURN
LDA :PROD+1
STA RETURN+1
LDA :PROD+2
STA RETURN+2
LDA :PROD+3
STA RETURN+3
LDA #4
STA RETLEN
LDA :MCAND
RTS
:PROD DS 4
:AXSIZE DS 1
:AYSIZE DS 1
:AXBAK DS 1
:AYBAK DS 1
:MLIER DS 2
:MCAND DS 2
********************************
AGET82
PLA
STA RETADR
PLA
STA RETADR+1
PLA
STA :YIDX
PLA
STA :XIDX
PLA
STA ADDR1
PLA
STA ADDR1+1
LDY #2
LDA (ADDR1),Y
STA :MCAND
LDA #0
STA :MCAND+1
LDA #0
TAY
STY SCRATCH
BEQ :ENTLP
:DOADD
CLC
ADC :XIDX
TAX
TYA
ADC SCRATCH
TAY
TXA
:LP
ASL :XIDX
ROL SCRATCH
:ENTLP
LSR :YIDX
BCS :DOADD
BNE :LP
STX :MLIER
STY :MLIER+1
LDA #0
STA :PROD+2
STA :PROD+3
LDX #$10
:SHIFTR LSR :MLIER+1
ROR :MLIER
BCC :ROTR
LDA :PROD+2
CLC
ADC :MCAND
STA :PROD+2
LDA :PROD+3
ADC :MCAND+1
:ROTR
ROR
STA :PROD+3
ROR :PROD+2
ROR :PROD+1
ROR :PROD
DEX
BNE :SHIFTR
CLC
INC :PROD
INC :PROD
INC :PROD
BCC :NOCAR
INC :PROD+1
:NOCAR
CLC
LDA :PROD
ADC ADDR1
STA :PROD
LDA :PROD+1
ADC ADDR1+1
STA :PROD+1
LDY :PROD
LDX :PROD+1
LDA RETADR+1
PHA
LDA RETADR
PHA
RTS
:XIDX DS 2
:YIDX DS 2
:PROD DS 4
:MLIER DS 2
:MCAND DS 2
********************************
APUT82
PLA
STA :RETADR
PLA
STA :RETADR+1
PLA
STA :YIDX
PLA
STA :XIDX
PLA
STA ADDR4
PLA
STA ADDR4+1
PLA
STA ADDR3
PLA
STA ADDR3+1
LDA ADDR4+1
PHA
LDA ADDR4
PHA
LDA :XIDX
PHA
LDA :YIDX
PHA
JSR AGET82
STY ADDR2
STX ADDR2+1
LDY #2
LDA (ADDR4),Y
STA :ESIZE
LDY #0
:CLP
LDA (ADDR3),Y
STA (ADDR2),Y
INY
CPY :ESIZE
BNE :CLP
LDA :RETADR+1
PHA
LDA :RETADR
PHA
LDX ADDR2+1
LDY ADDR2
LDA :ESIZE
RTS
:RETADR DS 2
:ESIZE DS 1
:XIDX DS 1
:YIDX DS 1
ARRAYS82X

46
disks/disk3_arrays/T.REQUIRED.HOOKS
View File

@ -1,46 +0,0 @@
*
*``````````````````````````````*
* DECLARATIONS.PUT *
*- -*
* USED IN CONJUNCTION WITH *
* OTHER PUT FILES. DEFINES *
* BASIC DECLARATIONS USED *
* ACROSS DIFFERENT ROUTINES *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
** ADDRESS STORAGE LOCATIONS FOR
** INDIRECT ADDRESSING.
*
ADDR1 EQU $06
ADDR2 EQU $08
ADDR3 EQU $EB
ADDR4 EQU $ED
*
** SCRATCHPAD ZERO PAGE LOCATIONS AND
** DEDICATED ZERO PAGE ADDRESS TO HOLD
** A RETURN ADDRESS PASSED VIA THE STACK
*
SCRATCH EQU $19
SCRATCH2 EQU $1E
RETADR EQU $FE
*
** ZERO PAGE ADDRESSES DEDICATED TO PASSING
** BACK RESULTS WHEN THERE ARE MORE THAN
** THREE BYTES BEING PASSED (AXY) AND THE
** USE OF THE STACK IS IMPRACTICAL OR TOO SLOW
*
RESULT EQU $FA
RESULT2 EQU $FC
*
** VARIOUS HOOKS USED BY ALL ROUTINES
*
REENTRY EQU $3D0
*
** ERROR HANDLING MEMORY LOCATIONS
*
** THIS DESIGNATES A 16-BYTE BLOCK OF MEMORY
** THAT HOLDS DATA RELATED TO IDENTIFYING
** RUNTIME VALUES FOR DEBUGGING.
*
ERRLOC EQU $0C00
*

10
disks/disk3_arrays/T.REQUIRED.HOOKS.MIN Normal file
View File

@ -0,0 +1,10 @@
ADDR1 EQU $06
ADDR2 EQU $08
ADDR3 EQU $EB
ADDR4 EQU $ED
SCRATCH EQU $19
SCRATCH2 EQU $1E
RETADR EQU $FE
RESULT EQU $FA
RESULT2 EQU $FC
REENTRY EQU $3D0

235
disks/disk3_arrays/T.REQUIRED.LIB
View File

@ -1,235 +0,0 @@
*
JMP ENDVARS
*
*``````````````````````````````*
* REQUIRED.LIB *
*- -*
* GLOBAL ROUTINES AND *
* VARIABLES EITHER USED BY THE *
* LIBRARY OR PROVIDED FOR DEMO *
* USE OR DEBUGGING PURPOSES. *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
********************************
* *
* GLOBAL ROUTINES *
* *
********************************
*
*``````````````````````````````*
* __GETRET: GET RETURN *
*- -*
* COPIES THE DATA IN [RETURN] *
* TO THE SPECIFIED LOCATION. *
* LENGTH IS DETERMINED BY *
* VALUE OF RETLEN. *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
__GETRET
*
LDY #255
PLA
STA ADDR1
PLA
STA ADDR1+1
*
:LP
INY
LDA RETURN,Y
STA (ADDR1),Y
CPY RETLEN
BNE :LP
LDA ADDR1+1
PHA
LDA ADDR1
PHA
RTS
*
*``````````````````````````````*
* __SETPARM: SET PARAMETER *
*- -*
* COPIES DATA FROM SPECIFIED *
* ADDRESS TO THE [PARAM] *
* LOCATION FOR PASSING TO *
* A ROUTINE. *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
__SETPARM
*
LDY #255
PLA
STA ADDR1
PLA
STA ADDR1+1
*
:LP
INY
LDA (ADDR1),Y
STA PARAM,Y
CPY PARLEN
BNE :LP
LDA ADDR1+1
PHA
LDA ADDR1
PHA
RTS
*
*``````````````````````````````*
* __DUMP: DUMP DATA *
*- -*
* OUTPUTS DATA LOCATED AT THE *
* SPECIFIED ADDRESS IN HEX *
* FORMAT FOR SPECIFIED NUMBER *
* OF BYTES. *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
__DUMP
*
PLA
STA :RET
PLA
STA :RET+1
PLA
STA :LENGTH
PLA
STA ADDR1
PLA
STA ADDR1+1
*
LDA #$8D
JSR $FDF0
LDA ADDR1+1
AND #$F0
LSR
LSR
LSR
LSR
TAX
LDA :HEXTAB,X
JSR $FDF0
LDA ADDR1+1
AND #$0F
TAX
LDA :HEXTAB,X
JSR $FDF0
LDA ADDR1
AND #$F0
LSR
LSR
LSR
LSR
TAX
LDA :HEXTAB,X
JSR $FDF0
LDA ADDR1
AND #$0F
TAX
LDA :HEXTAB,X
JSR $FDF0
LDA #186 ; :
JSR $FDF0
LDA #160 ; SPC
JSR $FDF0
*
LDY #0
:LP
LDA (ADDR1),Y
AND #$F0 ; MASK RIGHT
LSR
LSR
LSR
LSR
STA :LEFT
LDA (ADDR1),Y
AND #$0F ; MASK LEFT
STA :RIGHT
LDX :LEFT
LDA :HEXTAB,X
JSR $FDF0
LDX :RIGHT
LDA :HEXTAB,X
JSR $FDF0
LDA #160
JSR $FDF0
INY
CPY :LENGTH
BNE :LP
*
*LDA #$8D
*JSR $FDF0
LDA :RET+1
PHA
LDA :RET
PHA
*
RTS
*
:RET DS 2
:RIGHT DS 1
:LEFT DS 1
:LENGTH DS 1
:HEXTAB ASC "0123456789ABCDEF"
*
*``````````````````````````````*
* __P: PRINT FOLLOWING ASC *
*- -*
* THIS IS THE XPRINT ROUTINE *
* FROM STDIO.LIB, BUT STRIPPED *
* OF COMMENTS. FOR DEBUG. *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
__P
PLA
STA ADDR1
PLA
STA ADDR1+1
LDY #1
:LP LDA (ADDR1),Y
BEQ :DONE
JSR $FDF0
INY
BNE :LP
:DONE CLC
TYA
ADC ADDR1
STA ADDR1
LDA ADDR1+1
ADC #0
PHA
LDA ADDR1
PHA
RTS
*
*``````````````````````````````*
* __W: WAIT FOR KEYPRESS *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
__W
JSR $FD0C
RTS
*
********************************
* *
* GLOBAL VARIABLES *
* *
********************************
*
** 256 BYTES DEDICATED TO RETURN
** VALUES OF VARIABLE LENGTH; CAN BE
** MODIFIED TO SUIT SMALLER OR LARGER
** NEEDS.
*
*
RETLEN DS 1 ; RETURN VALUE BYTE LENGTH
RETURN DS 256
*
** 256 BYTE VALUE DEDICATED TO LARGE
** OR VARIABLE LENGTH PARAMETERS. THIS
** CAN ALSO BE CHANGED TO FIT SMALLER OR
** LARGER BOUNDS.
*
PARLEN DS 1
PARAM DS 256
*
ENDVARS
*

358
disks/disk3_arrays/T.REQUIRED.LIB.MIN Normal file
View File

@ -0,0 +1,358 @@
__GETRET
LDY #255
PLA
STA ADDR1
PLA
STA ADDR1+1
:LP
INY
LDA RETURN,Y
STA (ADDR1),Y
CPY RETLEN
BNE :LP
LDA ADDR1+1
PHA
LDA ADDR1
PHA
RTS
__SETPARM
LDY #255
PLA
STA ADDR1
PLA
STA ADDR1+1
:LP
INY
LDA (ADDR1),Y
STA PARAM,Y
CPY PARLEN
BNE :LP
LDA ADDR1+1
PHA
LDA ADDR1
PHA
RTS
__DUMP
PLA
STA :RET
PLA
STA :RET+1
PLA
STA :LENGTH
PLA
STA ADDR3
PLA
STA ADDR3+1
LDA #$8D
JSR $FDF0
LDA ADDR3+1
AND #$F0
LSR
LSR
LSR
LSR
TAX
LDA HEXTAB,X
JSR $FDF0
LDA ADDR3+1
AND #$0F
TAX
LDA HEXTAB,X
JSR $FDF0
LDA ADDR3
AND #$F0
LSR
LSR
LSR
LSR
TAX
LDA HEXTAB,X
JSR $FDF0
LDA ADDR3
AND #$0F
TAX
LDA HEXTAB,X
JSR $FDF0
LDA #186 ; :
JSR $FDF0
LDA #160 ; SPC
JSR $FDF0
LDY #0
:LP
LDA (ADDR3),Y
AND #$F0 ; MASK RIGHT
LSR
LSR
LSR
LSR
STA :LEFT
LDA (ADDR3),Y
AND #$0F ; MASK LEFT
STA :RIGHT
LDX :LEFT
LDA HEXTAB,X
JSR $FDF0
LDX :RIGHT
LDA HEXTAB,X
JSR $FDF0
LDA #160
JSR $FDF0
INY
CPY :LENGTH
BNE :LP
LDA :RET+1
PHA
LDA :RET
PHA
RTS
:RET DS 2
:RIGHT DS 1
:LEFT DS 1
:LENGTH DS 1
__P
PLA
STA ADDR1
PLA
STA ADDR1+1
LDY #1
:LP LDA (ADDR1),Y
BEQ :DONE
JSR $FDF0
INY
BNE :LP
:DONE CLC
TYA
ADC ADDR1
STA ADDR1
LDA ADDR1+1
ADC #0
PHA
LDA ADDR1
PHA
RTS
__W
JSR $FD0C
RTS
__RSAV
STA ERRA
STX ERRX
STY ERRY
:C BCC :C0
BCS :C1
:Z BEQ :Z1
BNE :Z0
:N BMI :N1
BPL :N0
:O BVC :O0
BVS :O1
JMP :EXIT
:C0 LDA #0
STA ERRCARRY
JMP :Z
:C1 LDA #1
STA ERRCARRY
JMP :Z
:Z1 LDA #1
STA ERRZERO
JMP :N
:Z0 LDA #0
STA ERRZERO
JMP :N
:N1 LDA #1
STA ERRNEG
JMP :O
:N0 LDA #0
STA ERRNEG
JMP :O
:O0 LDA #0
STA ERROVF
JMP :EXIT
:O1 LDA #1
STA ERROVF
:EXIT
RTS
__RDMP
_PRNT " ",8D8D
_PRNT "REGISTRY DUMP",8D
_PRNT "=============",8D
_PRNT "A: "
LDA ERRA
AND #$F0 ; MASK RIGHT
LSR
LSR
LSR
LSR
STA :LEFT
LDA ERRA
AND #$0F ; MASK LEFT
STA :RIGHT
LDX :LEFT
LDA HEXTAB,X
JSR $FDF0
LDX :RIGHT
LDA HEXTAB,X
JSR $FDF0
_PRNT " ",8D
_PRNT "X: "
LDA ERRX
AND #$F0 ; MASK RIGHT
LSR
LSR
LSR
LSR
STA :LEFT
LDA ERRX
AND #$0F ; MASK LEFT
STA :RIGHT
LDX :LEFT
LDA HEXTAB,X
JSR $FDF0
LDX :RIGHT
LDA HEXTAB,X
JSR $FDF0
_PRNT " ",8D
_PRNT "Y: "
LDA ERRY
AND #$F0 ; MASK RIGHT
LSR
LSR
LSR
LSR
STA :LEFT
LDA ERRY
AND #$0F ; MASK LEFT
STA :RIGHT
LDX :LEFT
LDA HEXTAB,X
JSR $FDF0
LDX :RIGHT
LDA HEXTAB,X
JSR $FDF0
_PRNT " ",8D8D
_PRNT "STATUS FLAGS",8D
_PRNT "============",8D8D
LDA #0
CMP ERRCARRY
BEQ :CARCLR
_PRNT "CARRY: SET",8D
JMP :TESTN
:CARCLR _PRNT "CARRY: CLEAR",8D
:TESTN LDA #0
CMP ERRNEG
BEQ :NEGCLR
_PRNT "NEGATIVE: SET",8D
JMP :TESTZ
:NEGCLR _PRNT "NEGATIVE: CLEAR",8D
:TESTZ LDA #0
CMP ERRZERO
BEQ :ZCLR
_PRNT "ZERO: SET",8D
JMP :TESTO
:ZCLR _PRNT "ZERO: CLEAR",8D
:TESTO
LDA #0
CMP ERROVF
BEQ :OCLR
_PRNT "OVERFLOW: SET",8D
JMP :FIN
:OCLR _PRNT "OVERFLOW: CLEAR",8D8D8D
:FIN
RTS
:LEFT DS 1
:RIGHT DS 1
HEXTAB ASC "0123456789ABCDEF"
__ERR
JSR __RSAV
PLA
STA RETADR
PLA
STA RETADR+1
PLA
STA :DUMPLEN ; LENGTH OF DUMP
PLA
STA :DUMP ; DUMP ADDRESS LO
PLA
STA :DUMP+1 ; DUMP HI
PLA
STA :DMPMSG
PLA
STA :DMPMSG+1
PLA
STA :MESG ; ERROR MESSAGE ADDR LO
PLA
STA :MESG+1 ; HI
PLA
STA :SRID ; SUBROUTINE ID ADDR LO
PLA
STA :SRID+1 ; SUB ID HI
_PRNT " ",87878787878D8D
_PRNT "ERROR!",8D8D
_PRNT "SUBROUTINE: "
LDY #0
LDA :SRID
STA ADDR1
LDA :SRID+1
STA ADDR1+1
:LP1
LDA (ADDR1),Y
BEQ :LPX1
JSR $FDF0
INY
BNE :LP1
:LPX1
_PRNT " ",8D
_PRNT "MESSAGE: "
LDY #0
LDA :MESG
STA ADDR1
LDA :MESG+1
STA ADDR1+1
:LP2
LDA (ADDR1),Y
BEQ :LPX2
JSR $FDF0
INY
BNE :LP2
:LPX2
_PRNT " ",8D8D
_WAIT
LDY #0
LDA :DMPMSG
STA ADDR1
LDA :DMPMSG+1
STA ADDR1+1
:LP3
LDA (ADDR1),Y
BEQ :LPX3
JSR $FDF0
INY
BNE :LP3
:LPX3
_PRNT " ",8D
LDA :DUMP+1
PHA
LDA :DUMP
PHA
LDA :DUMPLEN
PHA
JSR __DUMP
_WAIT
LDA RETADR+1
PHA
LDA RETADR
PHA
_PRNT " ",8D8D
_WAIT
_RDUMP
_WAIT
LDA ERRSTOP
CMP #1
BEQ :KILL
RTS
:KILL
JMP $3D0
:DUMPLEN DS 1
:DUMP DS 2
:DMPMSG DS 2
:MESG DS 2
:SRID DS 2

72
disks/disk3_arrays/T.REQUIRED.MAC
View File

@ -1,72 +0,0 @@
********************************
* *
********************************
*
*``````````````````````````````*
* REQUIRED.MAC *
*- -*
* MACROS USED FOR CORE UTILS *
* AND LIBRARY ROUTINES. NOTE *
* THAT THE LIBRARIES DO NOT *
* USE THESE MACROS, BUT MAY *
* USE THE ROUTINES. THESE ARE *
* MERELY PROVIDED FOR THE SAKE *
* OF CONVENIENCE. *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
*``````````````````````````````*
* _GRET: GET RETURN VALUE *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
_GRET MAC
LDA #>]1
PHA
LDA #<]1
PHA
JSR __GETRET
<<<
*
*``````````````````````````````*
* _SPAR: SET PARAMETER *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
_SPAR MAC
LDA #>]1
PHA
LDA #<]1
PHA
JSR __SETPARM
<<<
*
*``````````````````````````````*
* _DUMP: DUMP DATA *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
_DUMP MAC
LDA #>]1
PHA
LDA #<]1
PHA
LDA ]2
PHA
JSR __DUMP
<<<
*
*``````````````````````````````*
* _PRNT: PRINT STRING *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
_PRNT MAC
JSR __P
ASC ]1
HEX 00
<<<
*
*``````````````````````````````*
* _WAIT: WAIT FOR KEYPRESS *
*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,*
*
_WAIT MAC
JSR __W
<<<
*

94
disks/disk3_arrays/T.REQUIRED.MAC.MIN Normal file
View File

@ -0,0 +1,94 @@
_ISLIT MAC
IF #=]1 ; IF ]1 IS A LITERAL
LDA ]1/$100 ; GET HI
PHA
LDA ]1 ; GET LO
PHA
ELSE ; ]1 IS ADDRESS
LDA ]1+1 ; SO GET HIGH VAL FROM ADDR
PHA
LDA ]1 ; THEN LO VAL
PHA
FIN
<<<
_ISSTR MAC
IF "=]1 ; IF ]1 IS A STRING
JMP STRCONT
]STRTMP STR ]1
STRCONT
LDY #0
LDA ]STRTMP
STA PARLEN
STA PARAM
]STRLP1
INY
LDA ]STRTMP,Y
STA PARAM,Y
CPY PARLEN
BNE ]STRLP1
LDA #>PARAM ; GET HI
PHA
LDA #<PARAM ; GET LO
PHA
ELSE ; ]1 IS ADDRESS
LDA #>]1 ; SO GET HIBYTE OF ADDR
PHA
LDA #<]1 ; THEN LOBYTE
PHA
FIN
<<<
_GRET MAC
LDA #>]1
PHA
LDA #<]1
PHA
JSR __GETRET
<<<
_SPAR MAC
LDA #>]1
PHA
LDA #<]1
PHA
JSR __SETPARM
<<<
_DUMP MAC
LDA #>]1
PHA
LDA #<]1
PHA
LDA ]2
PHA
JSR __DUMP
<<<
_PRNT MAC
JSR __P
ASC ]1
HEX 00
<<<
_WAIT MAC
JSR __W
<<<
_RDUMP MAC
JSR __RDMP
<<<
_ERR MAC
LDA #>]1
PHA
LDA #<]1
PHA
LDA #>]2
PHA
LDA #<]2
PHA
LDA #>]3
PHA
LDA #<]3
PHA
LDA #>]4
PHA
LDA #<]4
PHA
LDA ]5
PHA
JSR __ERR
<<<

72
disks/disk3_arrays/T.REQUIRED.VARS Normal file
View File

@ -0,0 +1,72 @@
*
********************************
* *
* VARIABLES AND SETTINGS *
* *
********************************
*
* VARIABLE DECLARATIONS ********
*
** JUMP TABLE SETUP. THIS IS FOR LOADING
** SUBROUTINES INTO MEMORY FOR ACCESS BY
** EXTERNAL EXECUTIONS. NOTE THAT THIS
** SHOULD ALWAYS BE THE VERY FIRST BIT OF
** CODE IN THE PROGRAM SO THAT ITS
** LOCATION IN MEMORY IS EASILY KNOWN.
*
JUMPTBL JMP MAIN_START ; ** ALWAYS ** START WITH
; JUMP TO MAIN_START
DS 60 ; 20 MORE ENTRIES
*
** 256 BYTES DEDICATED TO RETURN
** VALUES OF VARIABLE LENGTH; CAN BE
** MODIFIED TO SUIT SMALLER OR LARGER
** NEEDS.
*
RETLEN DS 1 ; RETURN VALUE BYTE LENGTH
RETURN DS 256
*
** 256 BYTE VALUE DEDICATED TO LARGE
** OR VARIABLE LENGTH PARAMETERS. THIS
** CAN ALSO BE CHANGED TO FIT SMALLER OR
** LARGER BOUNDS.
*
PARLEN DS 1
PARAM DS 256
*
** ERROR HANDLING
*
ERRSTOP DS 1
ERRCTRL DS 1
ERRA DS 1
ERRX DS 1
ERRY DS 1
ERRCARRY DS 1
ERRNEG DS 1
ERRZERO DS 1
ERROVF DS 1
*
* SETTINGS *********************
*
MAIN_START
*
** ERROR HANDLING
*
** SET ERRSTOP TO 1 IF YOU WANT THE PROGRAM TO
** HALT WHEN AN ERROR IS CAUGHT
*
LDA #1
STA ERRSTOP
*
** SET ERRCTRL TO 1 IF YOU WANT ERROR CATCHING ON
** IN THE FIRST PLACE. HAVING THIS TURNED OFF WILL
** SAVE A FEW CYCLES, BUT POSSIBLY AT THE EXPENSE
** OF YOUR FRUSTRATION. CAN BE TURNED ON LATER THOUGH.
*
LDA #1
STA ERRCTRL
*
*
*
*
*