Programming:Filling memory with a byte - Revision history

Urusergi: /* Using the stack */

2018-03-17T23:15:44Z

Using the stack

← Older revision		Revision as of 23:15, 17 March 2018
Line 77:		Line 77:

	; Set up a fast 16-bit loop counter		; Set up a fast 16-bit loop counter
	~~dec de~~ ; This method takes advantage of the fact that DJNZ leaves B as 0, which subsequent DJNZs see as 256		ld b,e ; This method takes advantage of the fact that DJNZ leaves B as 0, which subsequent DJNZs see as 256
	~~ld b,e~~ ; B = (length/2) MOD 256, so 0 = a 512-byte block		dec de ; B = (length/2) MOD 256, so 0 = a 512-byte block
	inc b ; D = the number of 512-byte blocks to write, or just = 1 if the length is <512		inc d ; D = the number of 512-byte blocks to write, or just = 1 if the length is <512
	~~inc d~~ ; Of course, if you know the length ahead of run-time, you can set B and D directly in your ASM		; Of course, if you know the length ahead of run-time, you can set B and D directly in your ASM

	; Fill the memory		; Fill the memory

Db6128: /* Using the stack */

2012-12-14T17:52:11Z

Using the stack

← Older revision		Revision as of 17:52, 14 December 2012
Line 73:		Line 73:

	; Define the region of RAM to be filled		; Define the region of RAM to be filled
	ld h,~~YOUR_BYTE~~ ; Use HL or whichever 16-bit register you prefer		ld hl,YOUR_BYTE_1*&100 + YOUR_BYTE_2 ; Use HL or whichever 16-bit register you prefer
	~~ld l,YOUR_BYTE ; For 0, you can save 1 byte of memory by instead using XOR A:LD H,A:LD L,A~~		ld de,LENGTH_TO_FILL/2 ; divided by 2 because DE is 2 bytes wide and PUSH pushes both
	ld de,LENGTH_TO_FILL/2 ; divided by 2 because DE is 2 bytes wide and PUSH pushes both

	; Set up a fast 16-bit loop counter		; Set up a fast 16-bit loop counter

Db6128: /* Using the stack */ DErp

2012-12-14T01:02:03Z

Using the stack: DErp

← Older revision		Revision as of 01:02, 14 December 2012
Line 85:		Line 85:
	; Fill the memory		; Fill the memory
	PUSHLOOP:		PUSHLOOP:
	push hl ; Writes DE to (SP-2) and DECs SP by 2.		push hl ; Writes HL to (SP-2) and DECs SP by 2.
	; For even more speed, use multiple PUSH HLs in a row (I like 8, = &10 bytes) and adjust counters to match		; For even more speed, use multiple PUSH HLs in a row (I like 8, = &10 bytes) and adjust counters to match
	djnz PUSHLOOP		djnz PUSHLOOP

Db6128: adding SP-based method

2012-12-13T04:29:00Z

adding SP-based method

@@ Line 1: / Line 1: @@
 From the '''The Unofficial Amstrad WWW Resource'''
@@ Line 59: / Line 61: @@
 ;;
 ;; etc....
 </pre>
 [[Category:Programming]]

CPCLER at 16:48, 12 March 2007

2007-03-12T16:48:30Z

← Older revision		Revision as of 16:48, 12 March 2007
Line 1:		Line 1:
			From the '''The Unofficial Amstrad WWW Resource'''

	<pre>		<pre>
	;; This code snippet will show one method to fill a block		;; This code snippet will show one method to fill a block

Octoate: added category

2007-03-12T16:14:32Z

added category

← Older revision		Revision as of 16:14, 12 March 2007
Line 58:		Line 58:
	;; etc....		;; etc....
	</pre>		</pre>

			[[Category:Programming]]

CPCLER at 16:12, 12 March 2007

2007-03-12T16:12:26Z

New page

<pre>
;; This code snippet will show one method to fill a block
;; of memory with a single data byte using Z80 assembly
;; language.

;;--------------------------------------------------

;; HL = start address of block
ld hl,&4000

;; DE = HL + 1
ld e,l
ld d,h
inc de

;; initialise first byte of block
;; with data byte (&00)
ld (hl),&00

;; BC = length of block in bytes
;; HL+BC-1 = end address of block

ld bc,&4000

;; fill memory
ldir

;;--------------------------------------------------

;; For each iteration of the LDIR command:
;;
;; 1. This command will copy the byte from the memory
;; address pointed to by HL to the memory address pointed to by DE.
;; i.e. (DE) = (HL).
;; 2. Then HL and DE will be incremented. BC will be decremented.
;;
;;
;; For the first byte:
;;
;; HL = start
;; DE = start+1
;; BC = length
;; (HL)=0
;;
;; For the second byte:
;;
;; HL = start + 1 (initialised to 0 by the previous iteration)
;; DE = start + 2
;; BC = length - 1
;;
;; For the third byte:
;;
;; HL = start + 2 (initialised to 0 by the previous iteration)
;; DE = start + 3
;; BC = length - 2
;;
;; etc....
</pre>