Memory Manipulation Routines
------------------------------------------------------------------
1-101
Function Name: InitRam
Purpose: Uses a table to set various memory locations in a
uniform manner.
Call address: $C181
Input requirements:
$02-$03 R0 Address of a data table.
Description: This routine allows many memory locations to be
specified and set in an orderly manner. The format of the data
table is as follows:
#bytes Description
2 Address to store values at.
1 # of values that follow.
? Values to be stored at the designated memory
region.
... More definitions.
2 An address of $0000 ends the table.
1-102
Function Name: MoveData
Purpose: Intelligent block move.
Call address: $C17E
Input requirements:
$02-$03 R0 The source address.
$04-$05 R1 The destination address.
$06-$07 R2 The length of the region to be moved.
Description: This routine will perform an intelligent, i.e.
nonconflicting, block move of memory. If an attempt is made to
move a block of memory to a destination that is within the block,
the transfer is done from back to front so as to prevent the
conflict, or 'ripple effect'.
1-103
Function Name: i_MoveData
Purpose: Identical to MoveData, but with inline data.
Call address: $C1B7
Description: This routine uses the inline data to set everything
up before calling MoveData. For example:
JSR i_MoveData
.word Source address
.word Destination address
.word Length of transfer
Control returns here upon completion.
1-104
Function Name: FillRam
Purpose: Fills a memory region with a specified byte.
Call address: $C17B
Input requirements:
$02-$03 R0 The length of the region.
$04-$05 R1 The address of the region.
$06 R2L The byte to fill the region with.
Description: A simple loop fills memory with the specified byte.
1-105
Function Name: i_FillRam
Purpose: Identical to FillRam, but with inline data.
Call address: $C1B4
Description: This routine takes the inline data and sets
everything up before calling FillRam. For example:
JSR i_FillRam
.word Length of region
.word Address of region
.byte Byte to fill memory with
Control returns here upon completion.
1-106
Function Name: ClearRam
Purpose: Fills a memory region with zeroes.
Call address: $C178
Input requirements:
$02-$03 R0 The length of the region.
$04-$05 R1 The address of the region.
Description: Memory is filled with zeroes by storing a $00 at
location $06 and calling FillRam.
1-107
Function Name: CmpString
Purpose: Compare two strings for equality.
Call address: $C26B
Input requirements:
X Address of a zero page pointer.
Y Address of a zero page pointer.
Output:
Z flag Set accordingly.
Description: The X and Y registers point to zero page pointers.
The two strings are compared up to a zero byte. The Z flag is set
accordingly.
1-108
Function Name: CopyString
Purpose: Copy a string.
Call address: $C265
Input requirements:
X Address of zero page source pointer.
Y Address of zero page destination pointer.
Description: The X and Y registers point to zero page pointers.
Data is copied up to and including a zero byte. This routine is
used to copy strings by setting A to zero and calling CopyFString.
1-109
Function Name: CmpFString
Purpose: Compares two blocks of memory for a fixed length.
Call address: $C26E
Input requirements:
A Byte count.
X Address of zero page source pointer.
Y Address of zero page destination pointer.
Output:
Z flag Set accordingly.
Description: The X and Y registers point to zero page pointers. A
has the number of bytes to be compared (1-255). If A is zero,
this routine will compare up to and including a zero byte. The Z
flag is set accordingly. See CmpString.
1-110
Function Name: CopyFString
Purpose: Copy a block of memory.
Call address: $C268
Input requirements:
A Byte count.
X Address of zero page source pointer.
Y Address of zero page destination pointer.
Description: The X and Y registers point to zero page pointers.
A has the number of bytes to be transferred (1-255). If A is
zero, this routine will copy up to and including a zero byte. See
CopyString.
1-111
Function Name: StashRAM
Purpose: Copy a block of memory into an REU from main memory
Call address: $C2C8
Input requirements:
$02-$03 R0 Pointer to an address in main memory
$04-$05 R1 Address within the 64k REU bank addressed
$06-$07 R2 Number of bytes to swap, fetch, verify, etc.
$08 R3L REU 64k bank to work with
Output:
X Error code
A REU status
Description: The Y register is loaded with $90, and DoRamOp (see blow)
is called.
1-112
Function Name: FetchRAM
Purpose: Copies a block of memory from an REU into main memory
Call address: $C2CB
Input requirements:
$02-$03 R0 Pointer to an address in main memory
$04-$05 R1 Address within the 64k REU bank addressed
$06-$07 R2 Number of bytes to fetch
$08 R3L REU 64k bank to work with
Output:
X Error code
A REU status
Description: The Y register is loaded with $91, and DoRamOp (see blow)
is called.
1-113
Function Name: SwapRAM
Purpose: Swaps a block of main memory with an REU block
Call address: $C2CE
Input requirements:
$02-$03 R0 Pointer to an address in main memory
$04-$05 R1 Address within the 64k REU bank addressed
$06-$07 R2 Number of bytes to swap
$08 R3L REU 64k bank to work with
Output:
X Error code
A REU status
Description: The Y register is loaded with $92, and DoRamOp (see blow)
is called.
1-114
Function Name: VerifyRAM
Purpose: Verifies (compares) a block of memory to one in an REU
Call address: $C2D1
Input requirements:
$02-$03 R0 Pointer to an address in main memory
$04-$05 R1 Address within the 64k REU bank addressed
$06-$07 R2 Number of bytes verify
$08 R3L REU 64k bank to work with
Output:
X Error code
A REU status
Description: The Y register is loaded with $93, and DoRamOp (see blow)
is called.
1-115
Function Name: DoRamOp
Purpose: Move memory to and from an REU
Call address: $C2D4
Input requirements:
$02-$03 R0 Pointer to an address in main memory
$04-$05 R1 Address within the 64k REU bank addressed
$06-$07 R2 Number of bytes to swap, fetch, verify, etc.
$08 R3L REU 64k bank to work with
Y REU command to execute (see below)
Output:
X Error code
A REU status
Description: The Y register contains $90 to store, $91 for a fetch,
$92 for a memory swap, and $11 to verify (compare). R0 and R2 tell
this routine the block of main memory to store, swap, fetch, or
verify. R3L and R1 combine to form a 3-byte address within the REU
to work with.