jacobus

Add you favorite old User Groups... · June 1, 2021

HBO - Hamilton Burlington Oakville Atari Users Group (Ontario, Canada)

May 5, 2021

1 hour ago, devwebcl said:

What is the easiest game?

Seastalker is the easiest but it so simple (the game keeps offering help) that solving it does not feel satisfying at all.

I would recommend either The Witness (murder mystery) or Hollywood Hijinx (fairly logical puzzle solving) Planetfall is a bit tougher, but a lot of fun!

May 5, 2021

16 hours ago, atarialoha said:

Infocom really started going cheap when they stopped producing the original amazing boxed sets and made those flatpack boxes.

I think they didn't even include the feelies right?

It wasn't so much a matter of cheapness (the feelies were all included in the grey boxes) so much as outraged retailers who wanted smaller and more conventional packaging. Can you imagine trying to put the original StarCross saucer on a store shelf? Never mind the folios that either took up a massive amount of space when displayed face forward, or disappeared completely when shelved sideways.

May 4, 2021

26 minutes ago, atarialoha said:

I have heard Starcross is super difficult?

I might give Infidel a shot, since you rate it so highly. But first I want to try solving Deadline all over again.

The Witness was also the first one I solved.

I found it quite challenging! It's one of the only four Infocom games that can fit the entire program and data onto a single side of an Atari disk, so while the game is a bit short, the puzzles more than make up for it. Also, possibly the first of their games where the Feelies acted as copy protection - you will need the star map to progress past the first few moves. (feelies are also needed for Infidel - both at the beginning and throughout the game)

May 4, 2021

Zork I,II,III

Deadline

Starcross (with a friend - we spent an entire weekend hammering at it)

The Witness (the first one I solved)

Planetfall (my favourite - somewhere I have a printed walkthrough of the entire game)

Enchanter, Sorcerer, Spellbreaker

Infidel (a close second favourite)

Seastalker

The Hitchhiker's Guide to the Galaxy (with help (lots) from the Invisiclues)

Cutthroats

Hollywood Hijinx

The Lurking Horror (on the ST)

...all back in the day

I played RTZ to about the halfway point, but just couldn't finish - even getting that far was a grind

I tried to interest my kids in playing - even the avid readers weren't interested. Has anyone's offspring enjoyed them?

April 30, 2021

I'm a little late to the party, but I highly recommend a language called "Quick" from Raindorf Software, now available from DGS.

Basic-like syntax, compiles to fast machine code, gives you access to DLI, VBI, fine scrolling, etc.

(Still a work in progress, but this game is written in Quick) ZombieAttack RC3.xex

This DLI example makes the top part of the display appear to fade in by incrementally increasing the brightness of the first 8 scan lines

INTER DLI1 ;pfield0 A
LOCAL
 BYTE
 [
  V0,V1,V2,V3
 ]
BEGIN
 PUSH
 SYNC(1)
 CHBAS=168  ;alt1 charset
 VSCROL=VFS  ;set fs values for top

 *set starting colours
 V0=32    ;40   red-orange
 V1=160   ;168  blue grey
 V2=112   ;120  ultramarine
 V3=64    ;72   red

 *fade in
 REPEAT
  PFCOL0=V0
  PFCOL1=V1
  PFCOL2=V2
  PFCOL3=V3
  V0+
  V1+
  V2+
  V3+
  SYNC(1)
 UNTIL V0>=40

 DLI(DLIFOUT)  ;make next DLI active
 PULL
ENDDLI

April 21, 2021

On 3/19/2021 at 6:06 PM, Mathy said:

Hello guys

Eight slots would be very nice. And if that makes the box too long, just turn it over 90 degrees. (Yes, that's easier said than done)

Sincerely

Mathy

PS I'm not saying there should be only one version of the 1090.

Would it be possible to daisy-chain multiple units instead? Could that be one of the expansion cards?

April 6, 2021

On 3/9/2021 at 6:10 PM, Alfred said:

Found a few more pictures. First shows the two BBS slave machines (under the window) running the Puff BBS. Only the left XL answered the phone, I used the other to rarely chat with people on the BBS. Sticker on that 1050 tells me it's a USD drive. The next shows my original programming setup, circa 1992 I believe. The stack of 1050's didn't get used much since I had the mux. Last two are an early mux setup. The drive on top of the cabinet is a 47MB that I got for the super-low price of $650 back then. Inside the cabinet, the 8" 80MB Quantum drive is still in service, some cheap Adaptec controller on top. I'm not sure, the drive on the floor might be one of the 20MB 8" Quantums that Puff initially gave me, they went out of service when the 80MB arrived. The printer will be a Panasonic 1091, I had retired the Atari 1029 by then. As for the calendar, I had to bring that home from the office. People started complaining about it seeing it hanging on the wall in my cubicle. Heathens.

Nice setup Alfred! The amount of dust on that XL suggests it ran for a very long time without intervention. What was the name of your BBS? (I'm assuming it was local to the GTA)

The Toronto Sun Sunshine girls - the first page of the newspaper anyone ever turned to :-)

November 18, 2020

and a few more... (all NTSC)

imageproxy.php?img=&key=f4dcc336a70d5c68

October 25, 2020

I'd be interested in the right cart version

October 20, 2020

Take care Jay and get well soon!

October 5, 2020

That is the first software collection I've ever seen that does not include any pirated items! Amazing! ?

August 13, 2020

12 hours ago, Irgendwer said:
Why you don't just use the Quick-Command
FMOVE (Q,Z,L)
for that...?

Tried that ? It fails in the VBI.

August 12, 2020

1 hour ago, ivop said:

Could you post your VBI routine, and how it's calling memcopy? And how do you setup the VBI? It might be that registers (AXYP) are not preserved during the interrupt call.

Sure ? but it's in Quick so may not be much help. The PUSH/PULL, IPUSH/IPULL, ZPUSH/ZPULL (currently commented out) are supposed to be used to save and restore the CPU registers but the documentation is both confusing and contradictory and I have never quite figured out how to use them properly. Is this something I can add to the copy routine instead?

INTER VERTBLNK
LOCAL
 BYTE
 [
  V
 ]
 WORD
 [
  VD,VM
  OP=130,SP
 ]
BEGIN
* PUSH
* IPUSH
* ZPUSH
* SP=OP

 IF VBENABLE=1
  ZZC=0
  REPEAT
   CALL($00,$00,$00,$4C00)
   ZZC+
  UNTIL ZZC=33
  VBENABLE=0
 ENDIF

 *Horizontal Scrolling
 IF SCRLH=1 ;scroll right -->
  IF HFS=9
   IF HCS<16 ;limit of screen
    IF MAPXR<65
     HFS=12
     HCS+
    ENDIF
   ENDIF
  ELSE
   HFS-
  ENDIF
 ENDIF
 IF SCRLH=255 ;scroll left <--
  IF HFS=12
   IF HCS>0
    IF MAPXL>0
     HFS=9
     HCS-
    ENDIF
   ENDIF
  ELSE
   HFS+
  ENDIF
 ENDIF

 HSCR00=HCS
 HSCR01=HCS
 HSCR02=HCS
 HSCR03=HCS
 HSCR04=HCS
 HSCR05=HCS
 HSCR06=HCS
 HSCR07=HCS
 HSCR08=HCS
 HSCR09=HCS
 HSCR10=HCS
 HSCR11=HCS
 HSCR12=HCS
 HSCR13=HCS
 HSCR14=HCS
 HSCR15=HCS
 HSCR16=HCS

 *vertical scrolling
 IF SCRLV=1 ;top down (plyr moves up)
  IF VFS=0
   IF VCS>0
    IF MAPYT>0
     VSCR00-
     VSCR01-
     VSCR02-
     VSCR03-
     VSCR04-
     VSCR05-
     VSCR06-
     VSCR07-
     VSCR08-
     VSCR09-
     VSCR10-
     VSCR11-
     VSCR12-
     VSCR13-
     VSCR14-
     VSCR15-
     VSCR16-
     VFS=7
     VCS-
    ENDIF
   ENDIF
  ELSE
   VFS-
  ENDIF
 ENDIF

 IF SCRLV=255 ;bot up (plyr moves dn)
  IF VFS=7
   IF VCS<16
    IF MAPYB<64
     VSCR00+
     VSCR01+
     VSCR02+
     VSCR03+
     VSCR04+
     VSCR05+
     VSCR06+
     VSCR07+
     VSCR08+
     VSCR09+
     VSCR10+
     VSCR11+
     VSCR12+
     VSCR13+
     VSCR14+
     VSCR15+
     VSCR16+
     VFS=0
     VCS+
    ENDIF
   ENDIF
  ELSE
   VFS+
  ENDIF
 ENDIF

 *handle joystick
 IF STICK0<>15
  V=JOYX(STICK0) ;LUT
  ADD(PX,V,PX)
  SCRLH=0 ;no scroll flag
  IF PX<124
   SUB(PX,V,PX)
   SCRLH=255 ;scroll left flag <--
  ENDIF
  IF PX>125
   SUB(PX,V,PX)
   SCRLH=1 ;scroll right flag -->
  ENDIF

  V=JOYY(STICK0) ;LUT
  ADD(PY,V,PY)
  SCRLV=0
  IF PY<119
   SUB(PY,V,PY)
   SCRLV=1
  ENDIF
  IF PY>121
   SUB(PY,V,PY)
   SCRLV=255
  ENDIF



 ELSE
  SCRLH=0
  SCRLV=0
 ENDIF

* OP=SP
* PULL
* IPULL
* ZPULL
ENDVBI

August 12, 2020

4 hours ago, ivop said:

Exactly main is just an example of how you call memcopy, i.e. setup src, load dst in AX and size in Y, and call the routine. ($1234 and $5678 are just example source and destination addresses)

@StickJock's code is off by one. It copies bytes 1-56 instead of 0-55. But the unroll is correct and faster. You could add the same trick of having set COPYSOURCE (src in my case) by the caller, and COPYDEST (dst) by the callee, to save space everywhere you call this routine.

Thanks for all the help, I am definitely closer! The code (with some very minor changes) works when called from the main part of the program but fails when run in the VBI. I should elaborate - it runs properly once when called from the VBI but then locks up the computer. Do I need to do something different when exiting?

.lsfirst

zplocation		.equ	$CC	;; Uses memory locations starting at this address.
org			.equ	$4C00	;; Start of main code

src			.equ	zplocation+$0	;; Source
dst			.equ	zplocation+$2	;; Destination
bytes			.equ	zplocation+$4	;; Size

		.org	org

; caller sets src & dst & bytes
; Y is size minus 1(!), maximum of 127 (i.e. 128 bytes)

memcopy
;	sta dst
;	stx dst+1
        ldy bytes

loop
	lda (src),y
	sta (dst),y
	dey
	bpl loop

	rts

	.end

August 12, 2020

23 hours ago, StickJock said:

If you don't care about code size, and you want it as fast as possible, and the source & destination blocks can change every time, then I think that the fastest would be to set up your source & destination addresses in a pair of zero page words, and then use an unrolled-loop of repeated LDA (source),Y ; STA (dest),Y ; DEY

Your subroutine could look something like this:

Reveal hidden contents

COPY56BYTES:

LDY #56

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y ; 55

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y ; 50

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

COPY48BYTESWITHYPRELOADEDWITH48:

LDA (COPYSOURCE),Y ; 48

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y ; 45

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y ; 40

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y ; 35

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y ; 30

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y ; 25

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y ; 20

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y ;15

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y ; 10

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y ; 5

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

DEY

LDA (COPYSOURCE),Y

STA (COPYDEST),Y

RTS

After loading your source address in COPYSOURCE and your destination address in COPYDEST, you can call COPY56BYTES to do the copy as fast as possible.

If you want to copy 48 bytes, then also load Y with 48 and call COPY48BYTESWITHYPRELOADEDWITH48. If you need some other number of bytes copied, you can add labels in the appropriate place in the unrolled loop and call them (with Y preloaded as appropriate).

I think that this will give you the fastest memory copy, using 2 + N*(5+6+2) - 2 + 6 cycles, not counting the JSR and the loading of the COPYSOURCE & COPYDEST words.

As for size, this sub will take 2+N*5 bytes. So, for N=56, it will be 282 bytes long. If you want the speed, you have to pay for it somewhere else!

Thank you for this! Once I get the code working, I'll come back to this for now, I'll go with readability ?

August 12, 2020

Is there any significant difference between 800 motherboards? I have a revision 9 with white/light grey cartridge slots and a rev A with black ones...

August 12, 2020

On 6/1/2020 at 9:07 PM, jacobus said:

Does anyone know if the 16K 800's (like the above) shipped with 1 x 16K board or 2 x 8K? Also, any idea when Atari stopped using tin contacts and switched to gold?

When ? ?

August 11, 2020

On 8/10/2020 at 11:44 AM, ivop said:
Do you cross page boundaries? Can page zero be a source or destination location?

Edit: do source and destination frequently change? Is self-modifying code allowed or might it need to run from ROM? Undocumented (not illegal) instructions, or should it also work on non-stanard machine with a 65C02 and up?

Edit2: tight code, or speed?

Edit3: size maximum of 128, 256, or more?

There are so many factors

Here's a sample:
src			.equ	zplocation+$0
dst			.equ	zplocation+$2

; caller sets src
; enter with A lo(dst) and X hi(dst)
; Y is size minus 1(!), maximum of 127 (i.e. 128 bytes)

memcopy
	sta dst
	stx dst+1

loop
	lda (src),y
	sta (dst),y
	dey
	bpl loop

	rts

main
	lda #$34	; lo($1234)
	sta src
	lda #$12	; hi($1234)
	sta src+1

	lda #$78	; lo($5678)
	ldx #$56	; hi($5678)
	ldy #55		; 56 bytes
	jsr memcopy

	rts
I moved storing of dst to the memcopy routine. That saves space at the caller side. No need to sta dst/stx dst+1 everytime you call memcopy.

This could be improved upon a lot, depending on your specific needs

Thank you very much for the reply!

in answer tour questions:

-I do not cross page bountries

-zero page is not used as a source or destination

-source and destination change each time the copy routine will be called

-rather not have self-modifying code, I may put this in a cart

-speed is my preference - I need to copy 56 bytes 32 times for a full screen redraw

-when you say size - do you mean size of code or bytes copied? Code size is not too important, (under 256 bytes preferred), bytes copied each call is either 48 or 56

Questions

-I understand the first two routines, but I don't understand why in the main routine at all. Why the constants ($1234 and $5678)?

thank you!

Edit: Wait a second, do memcopy and loop perform the actual copy and main simply sets up and calls it?

August 10, 2020

On 7/30/2020 at 6:04 PM, ilmenit said:

64 bytes fit in one page what can greatly simplify the code. Do you select source or destination location? Is at least one of them constant?

Both source and destination are variable - the amount of data to copy is always 56 bytes - however I think I'd like to be able to specify that as well just in case I find another use for this code.

August 10, 2020

On 7/30/2020 at 3:32 PM, zbyti said:

@jacobus and what's wrong with the procedure from Action! runtime? It is pure ML easy to rewrite in any assembly

Nothing, but I couldn't see how to pass the parameters that I need - sorry to have ignored your response!

August 6, 2020

Time to make some space!

Reasonable offers considered, I will ship to US and Canada. If you are interested in a trade, I am looking for the packaging that comes with Synapse's Page 6 utility.

Please read the descriptions beside each item - feel free to ask questions!

Boxed 1050 in almost new condition. Tested and working. All components included. Box has some brown packing tape attached. Includes DOS 3 !!! ?

400 - includes Tara aftermarket keyboard. Early model - Week 12 of 1981. Machine powers up but does not boot or display anything. Parts only!

48K 800 - Parts only - missing spring from door latch, IO bezel and clear plastic power light carrier. Small chip in front right corner.

810 Drive - powers up, spins but otherwise does not respond. Small chip on one side. For parts.

2 - 850 interfaces - they power up but otherwise not tested. One has some fairly significant case damage.

XEGS #1 - Bad ROM (no basic or Missile command), runs the cartridges I tested with, but no guarantees. Does not respond to keyboard.

XEGS #2 - Tested and working except for sticky console keys (Option works only intermittently)

XEGS #3 - Tested and working properly

July 30, 2020

thanks for the responses!

Sounds like I was starting with the wrong code. Can anyone recommend an assembly routine that would do the following:

-Copy small sequences of data (<64 bytes) from one location to another

-Run in the VBI

-Compatible with the TASM cross assembler version 3.2

-Fast and light

thank you!

July 29, 2020

6 hours ago, dmsc said:

Hi!

Are you trying to convert this routine - that as made to be called from CC65 compiled C code - to an ASM only code?

Then, you should simply remove the usage of "SP" (the C stack) altogether, and assume that ptr1, ptr2 and ptr2 have the parameters:


;
; Ullrich von Bassewitz, 2003-08-20
; Performance increase (about 20%) by
; Christian Krueger, 2009-09-13
;

.lsfirst

;;
;; TASM Macros and Defines
;;
#define lo(work)                (work & $00FF)
#define hi(work)                ((work & $FF00) >> 8)
#define bitprefix		.byte $2C

zplocation		.equ	$CC	;; Uses memory locations starting at this address.  Make sure they are not in use by the system or your program.
org			.equ	$4C00	;; Start of main code

ptr1			.equ	zplocation+$0	;; Source
ptr2			.equ	zplocation+$2	;; Destination
ptr3			.equ	zplocation+$4	;; Size

		.org	org

memcpy
        ldy     #0              ; Needs Y = 0
        ldx     ptr3+1          ; Get high byte of n
        beq     L2              ; Jump if zero

L1      	                ; Unrolled to make it faster...
        lda     (ptr1),Y        ; copy a byte
        sta     (ptr2),Y
        iny
        lda     (ptr1),Y        ; copy a byte
        sta     (ptr2),Y
        iny

        bne     L1
        inc     ptr1+1
        inc     ptr2+1
        dex                     ; Next 256 byte block
        bne     L1              ; Repeat if any

        ; the following section could be 10% faster if we were able to copy
        ; back to front - unfortunately we are forced to copy strict from
        ; low to high since this function is also used for
        ; memmove and blocks could be overlapping!
L2                              ; assert Y = 0
        ldx     ptr3            ; Get the low byte of n
        beq     done            ; something to copy

L3      lda     (ptr1),Y        ; copy a byte
        sta     (ptr2),Y
        iny
        dex
        bne     L3

done    rts                     ; return

	.end

Have Fun!

Thank you - much appreciated!

Progress! It now simply hangs the computer instead of crashing Altirra! ? I think I forgot to mention that this needs to run in the VBI. Does that change anything?

July 28, 2020

I assume this is eye-rollingly simple, but I'll ask anyway ...

I'm trying to modify a general purpose copy routine to use three parameters - a source location, a destination location and the number of bytes to copy. Can someone please have a look at the attached code and tell me what I am doing wrong?

;
; Ullrich von Bassewitz, 2003-08-20
; Performance increase (about 20%) by
; Christian Krueger, 2009-09-13
;
; void* __fastcall__ memcpy (void* dest, const void* src, size_t n);
;
; NOTE: This function contains entry points for memmove, which will resort
; to memcpy for an upwards copy. Don't change this module without looking
; at memmove!
;

;        .export         _memcpy, memcpy_upwards, memcpy_getparams
;        .import         popax, popptr1
;        .importzp       sp, ptr1, ptr2, ptr3

; ----------------------------------------------------------------------
;;
;; compiler directives
;;

.lsfirst

;;
;; TASM Macros and Defines
;;
#define lo(work)                (work & $00FF)
#define hi(work)                ((work & $FF00) >> 8)
#define bitprefix		.byte $2C

zplocation		.equ	$CC	;; Uses memory locations starting at this address.  Make sure they are not in use by the system or your program.
org			.equ	$4C00	;; Start of main code

sp			.equ	zplocation+$0	;; Source pointer
ptr1			.equ	zplocation+$2	;; Source
ptr2			.equ	zplocation+$4	;; Destination
ptr3			.equ	zplocation+$6	;; Size

popax			.equ	$BA	;; 
popptr1			.equ	$BB	;; 

		;;
program_start	;;
		;;

		.org	org


_memcpy
        jsr     memcpy_getparams
 	.export _memcpy

memcpy_upwards                  ; assert Y = 0
        ldx     ptr3+1          ; Get high byte of n
        beq     L2              ; Jump if zero

L1      	                ; Unrolled to make it faster...
        lda     (ptr1),Y        ; copy a byte
        sta     (ptr2),Y
        iny
        lda     (ptr1),Y        ; copy a byte
        sta     (ptr2),Y
        iny

        bne     L1
        inc     ptr1+1
        inc     ptr2+1
        dex                     ; Next 256 byte block
        bne     L1              ; Repeat if any

        ; the following section could be 10% faster if we were able to copy
        ; back to front - unfortunately we are forced to copy strict from
        ; low to high since this function is also used for
        ; memmove and blocks could be overlapping!
        ; {
L2                              ; assert Y = 0
        ldx     ptr3            ; Get the low byte of n
        beq     done            ; something to copy

L3      lda     (ptr1),Y        ; copy a byte
        sta     (ptr2),Y
        iny
        dex
        bne     L3

        ; }

done    jmp     popax           ; Pop ptr and return as result
	.export memcpy_upwards 

; ----------------------------------------------------------------------
; Get the parameters from stack as follows:
;
;       size            --> ptr3
;       src             --> ptr1
;       dest            --> ptr2
;       First argument (dest) will remain on stack and is returned in a/x!

memcpy_getparams                ; IMPORTANT! Function has to leave with Y=0!
        sta     ptr3
        stx     ptr3+1          ; save n to ptr3

        jsr     popptr1         ; save src to ptr1

                                ; save dest to ptr2
        iny                     ; Y=0 guaranteed by popptr1, we need '1' here...                        
                                ; (direct stack access is three cycles faster
                                ; (total cycle count with return))
        lda     (sp),y
        tax
        stx     ptr2+1          ; save high byte of ptr2
        dey                     ; Y = 0
        lda     (sp),y          ; Get ptr2 low
        sta     ptr2
        rts
	.export memcpy_getparams

	.end

thank you!

Copy.A65

Profiles

Forums

Blogs

Gallery

Events

Store

Posts posted by jacobus