General Information
Author: Andrew John Jacobs
Published: 1999

This file contains a number of useful 6502 algorithms for number, string and memory operations. The code is written in the form of macros rather than subroutines to make them more flexible.

The routines in the library assume that 16 and 32 bit numbers are represented in little endian order, that is the least significant byte in the lowest memory location, so that they can be applied to addresses as well as pure numbers.

The string routines assume that they are working with null terminated 'C' style strings.

The main routines sacrifice code size for speed and are coded without any iteration. Compact versions which use iteration are provided for some algorithms and have the same name as the original routine with a 'C' suffix (eg. _XFR32 => _XFR32C).

Some of the macros use 65SC02 instructions for speed or to reduce the amount code generated if the assembler will accept them.

Where possible the macros detect optimizable cases and generate more efficient code.

Bugs & Enhancments:

If you find a bug I missed or have a new routine you would like to submit to the library then mail me at:

Andrew@obelisk.demon.co.uk

fount at http://www.obelisk.demon.co.uk/6502/algorithms.html


      NOLIST
;------------------------------------------------
; 6502 Standard Macro Library
;------------------------------------------------
; Copyright (C),1999 Andrew John Jacobs.
; All rights reserved.
;------------------------------------------------

;------------------------------------------------
; Revision History:
;
; 16-Aug-99 AJJ   Initial version.
;
; 14-Nov-01 AJJ Finally got around to filling in
;      some missing comments.
;
;------------------------------------------------

; Notes:
;
; This file contains a number of useful 6502
; algorithms for number, string and memory
; operations. The code is written in the form of
; macros rather than subroutines to make them
; more flexible.
;
; The routines in the library assume that 16 and
; 32 bit numbers are represented in little endian
; order, that is the least significant byte in
; the lowest memory location, so that they can
; be applied to addresses as well as pure
; numbers.
;
; The string routines assume that they are
; working with null terminated 'C' style strings.
;
; The main routines sacrifice code size for speed
; and are coded without any iteration. Compact
; versions which use iteration are provided for
; some algorithms and have the same name as the
; original routine with a 'C' suffix (eg. _XFR32
; => _XFR32C).
;
; Some of the macros use 65SC02 instructions for
; speed or to reduce the amount code generated if
; the assembler will accept them.
;
; Where possible the macros detect optimizable
; cases and generate more efficient code.
;
; Bugs & Enhancments:
;
; If you find a bug I missed or have a new
; routine you would like to submit to the library
; then mail me at:
;
; Andrew@obelisk.demon.co.uk

      PAGE
;------------------------------------------------
; Basic Operations
;------------------------------------------------

; Clear 2 bytes of memory at any location by
; setting it to zero. If 65SC02 instructions are
; available then STZ is used.
;
; On exit: A = ??, X & Y are unchanged.

      IF __65SC02__
_CLR16       MACRO MEM
       STZ MEM+0
       STZ MEM+1
       ENDM
      ELSE
_CLR16       MACRO MEM
       LDA #0
       STA MEM+0
       STA MEM+1
       ENDM
      ENDIF

; Clear 4 bytes of memory at any location by
; setting it to zero. If 65SC02 instructions are
; available then STZ is used.
;
; On exit: A = ??, X & Y are unchanged.

      IF __65SC02__
_CLR32       MACRO MEM
       STZ MEM+0
       STZ MEM+1
       STZ MEM+2
       STZ MEM+3
       ENDM
      ELSE
_CLR32       MACRO MEM
       LDA #0
       STA MEM+0
       STA MEM+1
       STA MEM+2
       STA MEM+3
       ENDM
      ENDIF

; Clear 4 bytes of memory at any location by
; setting it to zero iteratively. If 65SC02
; instructions are available then STZ is used.
;
; On exit: A = ??, X = $FF, Y is unchanged.

      IF __65SC02__
_CLR32C       MACRO MEM
       LDX #3
_LOOP\?       STZ MEM,X
       DEX
       BPL _LOOP\?
       ENDM
      ELSE
_CLR32C       MACRO MEM
       LDA #0
       LDX #3
_LOOP\?       STA MEM,X
       DEX
       BPL _LOOP\?
       ENDM
      ENDIF

; Transfer 2 bytes of memory from one location to
; another using the accumulator. The order in
; which the bytes are moved depends on the
; relative positions of SRC and DST. If SRC and
; DST are the same then no code is generated.
;
; On exit: A = ??, X & Y are unchanged.

_XFR16      MACRO SRC,DST
      IF SRC != DST
       IF SRC > DST
        LDA SRC+0
        STA DST+0
        LDA SRC+1
        STA DST+1
       ELSE
        LDA SRC+1
        STA DST+1
        LDA SRC+0
        STA DST+0
       ENDIF
      ENDIF
      ENDM

; Transfer 4 bytes of memory from one location to
; another using the accumulator. The order in
; which the bytes are moved depends on the
; relative positions of SRC and DST. If SRC and
; DST are the same then no code is generated.
;
; On exit: A = ??, X & Y are unchanged.

_XFR32      MACRO SRC,DST
      IF SRC != DST
       IF SRC > DST
        LDA SRC+0
        STA DST+0
        LDA SRC+1
        STA DST+1
        LDA SRC+2
        STA DST+2
        LDA SRC+3
        STA DST+3
       ELSE
        LDA SRC+3
        STA DST+3
        LDA SRC+2
        STA DST+2
        LDA SRC+1
        STA DST+1
        LDA SRC+0
        STA DST+0
       ENDIF
      ENDIF
      ENDM

; Transfer 4 bytes of memory from one location to
; another iteratively using the accumulator. The
; transfer may fail if SRC and DST overlap. If
; SRC and DST are the same then no code is
; generated.
;
; On exit: A = ??, X = $FF, Y is unchanged.

_XFR32C      MACRO SRC,DST
      IF SRC != DST
       LDX #3
_LOOP\?       LDA SRC,X
       STA DST,X
       DEX
       BPL _LOOP\?
      ENDIF
      ENDM

; Set the value of a 16 bit location DST with
; the given constant value.
;
; On exit: A = ??, X & Y unchanged.

_SET16I      MACRO NUM,DST
      IF NUM != 0
       LDA #LO NUM
       STA DST+0
       LDA #HI NUM
       STA DST+1
      ELSE
       _CLR16 DST
      ENDIF

      PAGE
;------------------------------------------------
; Logical Operations
;------------------------------------------------

; Calculate the logical NOT of the 16 bit value
; at location VLA and stores it in location RES.
;
; On exit: A = ??, X & Y are unchanged.

_NOT16      MACRO VLA,RES
      LDA VLA+0
      EOR #$FF
      STA RES+0
      LDA VLA+1
      EOR #$FF
      STA RES+1
      ENDM

; Calculate the logical NOT of the 32 bit value
; at location VLA and stores it in location RES.
;
; On exit: A = ??, X & Y are unchanged.

_NOT32      MACRO VLA,RES
      LDA VLA+0
      EOR #$FF
      STA RES+0
      LDA VLA+1
      EOR #$FF
      STA RES+1
      LDA VLA+2
      EOR #$FF
      STA RES+2
      LDA VLA+3
      EOR #$FF
      STA RES+3
      ENDM

; Calculate the logical NOT of the 32 bit value
; at location VLA iteratively and stores it in
; location RES.
;
; On exit: A = ??, X = $FF, Y are unchanged.

_NOT32C      MACRO VLA,RES
      LDX #3
_LOOP\?      LDA VLA,X
      EOR #$FF
      STA RES,X
      DEX
      BPL _LOOP\?
      ENDM

; Calculate the logical OR of the two 16 bit
; values at locations VLA and VLB. The result is
; stored in location RES. If VLA and VLB are the
; same the macro expands to a _XFR16.
;
; On exit: A = ??, X & Y are unchanged.

_ORA16      MACRO VLA,VLB,RES
      IF VLA != VLB
       LDA VLA+0
       ORA VLB+0
       STA RES+0
       LDA VLA+1
       ORA VLB+1
       STA RES+1
      ELSE
       _XFR16 VLA,RES
      ENDIF
      ENDM

; Calculate the logical OR of a 16 value at
; location VLA with a constant value and
; store the result at location RES.
;
; On exit: A = ??, X & Y are unchanged.

_ORA16I      MACRO VLA,NUM,RES
       LDA VLA+0
       ORA #LO NUM
       STA RES+0
       LDA VLA+1
       ORA #HI NUM
       STA RES+1
      ENDM

; Calculate the logical OR of the two 32 bit
; values at locations VLA and VLB. The result is
; stored in location RES. If VLA and VLB are the
; same the macro expands to a _XFR32.
;
; On exit: A = ??, X & Y are unchanged.

_ORA32      MACRO VLA,VLB,RES
      IF VLA != VLB
       LDA VLA+0
       ORA VLB+0
       STA RES+0
       LDA VLA+1
       ORA VLB+1
       STA RES+1
       LDA VLA+2
       ORA VLB+2
       STA RES+2
       LDA VLA+3
       ORA VLB+3
       STA RES+3
      ELSE
       _XFR32 VLA,RES
      ENDIF
      ENDM

; Calculate the logical OR of the two 32 bit
; values at locations VLA and VLB iteratively.
; The result is stored in location RES. If VLA
; and VLB are the same the macro expands to a
; _XFR32C.
;
; On exit: A = ??, X = $FF, Y is unchanged.

_ORA32C      MACRO VLA,VLB,RES
      IF VLA != VLB
       LDX #3
_LOOP\?       LDA VLA,X
       ORA VLB,X
       STA RES,X
       DEX
       BPL _LOOP\?
      ELSE
       _XFR32C VLA,RES
      ENDIF
      ENDM

; Calculate the logical AND of the two 16 bit
; values at locations VLA and VLB. The result is
; stored in location RES. If VLA and VLB are the
; same the macro expands to a _XFR16.
;
; On exit: A = ??, X & Y are unchanged.

_AND16      MACRO VLA,VLB,RES
      IF VLA != VLB
       LDA VLA+0
       AND VLB+0
       STA RES+0
       LDA VLA+1
       AND VLB+1
       STA RES+1
      ELSE
       _XFR16 VLA,RES
      ENDIF
      ENDM

; Calculate the logical AND of a 16 value at
; location VLA with a constant value and
; store the result at location RES.
;
; On exit: A = ??, X & Y are unchanged.

_AND16I      MACRO VLA,NUM,RES
       LDA VLA+0
       AND #LO NUM
       STA RES+0
       LDA VLA+1
       AND #HI NUM
       STA RES+1
      ENDM

; Calculate the logical AND of the two 32 bit
; values at locations VLA and VLB. The result is
; stored in location RES. If VLA and VLB are the
; same the macro expands to a _XFR32.
;
; On exit: A = ??, X & Y are unchanged.

_AND32      MACRO VLA,VLB,RES
      IF VLA != VLB
       LDA VLA+0
       AND VLB+0
       STA RES+0
       LDA VLA+1
       AND VLB+1
       STA RES+1
       LDA VLA+2
       AND VLB+2
       STA RES+2
       LDA VLA+3
       AND VLB+3
       STA RES+3
      ELSE
       _XFR32 VLA,RES
      ENDIF
      ENDM

; Calculate the logical AND of the two 32 bit
; values at locations VLA and VLB iteratively.
; The result is stored in location RES. If VLA
; and VLB are the same the macro expands to a
; _XFR32C.
;
; On exit: A = ??, X = $FF, Y is unchanged.

_AND32C      MACRO VLA,VLB,RES
      IF VLA != VLB
       LDX #3
_LOOP\?       LDA VLA,X
       AND VLB,X
       STA RES,X
       DEX
       BPL _LOOP\?
      ELSE
       _XFR32C VLA,RES
      ENDIF
      ENDM

; Calculate the exclusive OR of the two 16 bit
; values at locations VLA and VLB. The result is
; stored in location RES. If VLA and VLB are the
; same the macro expands to a _CLR16.
;
; On exit: A = ??, X & Y are unchanged.

_EOR16      MACRO VLA,VLB,RES
      IF VLA != VLB
       LDA VLA+0
       EOR VLB+0
       STA RES+0
       LDA VLA+1
       EOR VLB+1
       STA RES+1
      ELSE
       _CLR16 RES
      ENDIF
      ENDM

; Calculate the exclusive OR of a 16 value at
; location VLA with a constant value and
; store the result at location RES.
;
; On exit: A = ??, X & Y are unchanged.

_EOR16I      MACRO VLA,NUM,RES
       LDA VLA+0
       EOR #LO NUM
       STA RES+0
       LDA VLA+1
       EOR #HI NUM
       STA RES+1
      ENDM

; Calculate the exclusive OR of the two 32 bit
; values at locations VLA and VLB. The result is
; stored in location RES. If VLA and VLB are the
; same the macro expands to a _CLR32.
;
; On exit: A = ??, X & Y are unchanged.

_EOR32      MACRO VLA,VLB,RES
      IF VLA != VLB
       LDA VLA+0
       EOR VLB+0
       STA RES+0
       LDA VLA+1
       EOR VLB+1
       STA RES+1
       LDA VLA+2
       EOR VLB+2
       STA RES+2
       LDA VLA+3
       EOR VLB+3
       STA RES+3
      ELSE
       _CLR32 RES
      ENDIF
      ENDM

; Calculate the exclusive OR of the two 32 bit
; values at locations VLA and VLB iteratively.
; The result is stored in location RES. If VLA
; and VLB are the same the macro expands to a
; _XFR32C.
;
; On exit: A = ??, X = $FF, Y is unchanged.

_EOR32C      MACRO VLA,VLB,RES
      IF VLA != VLB
       LDX #3
_LOOP\?       LDA VLA,X
       EOR VLB,X
       STA RES,X
       DEX
       BPL _LOOP\?
      ELSE
       _CLR32C RES
      ENDIF
      ENDM

      PAGE
;------------------------------------------------
; Shift Operations
;------------------------------------------------

; Perform an arithmetic shift left on the 16 bit
; number at location VLA and store the result at
; location RES. If VLA and RES are the same then
; the operation is applied directly to the memory
; otherwise it is done in the accumulator.
;
; On exit: A = ??, X & Y are unchanged.

_ASL16      MACRO VLA,RES
      IF VLA != RES
       LDA VLA+0
       ASL A
       STA RES+0
       LDA VLA+1
       ROL A
       STA RES+1
      ELSE
       ASL VLA+0
       ROL VLA+1
      ENDIF
      ENDM

; Perform an arithmetic shift left on the 32 bit
; number at location VLA and store the result at
; location RES. If VLA and RES are the same then
; the operation is applied directly to the memory
; otherwise it is done in the accumulator.
;
; On exit: A = ??, X & Y are unchanged.

_ASL32      MACRO VLA,RES
      IF VLA != RES
       LDA VLA+0
       ASL A
       STA RES+0
       LDA VLA+1
       ROL A
       STA RES+1
       LDA VLA+2
       ROL A
       STA RES+2
       LDA VLA+3
       ROL A
       STA RES+3
      ELSE
       ASL VLA+0
       ROL VLA+1
       ROL VLA+2
       ROL VLA+3
      ENDIF
      ENDM

; Perform a left rotation on the 16 bit number at
; location VLA and store the result at location
; RES. If VLA and RES are the same then the
; operation is applied directly to the memory,
; otherwise it is done in the accumulator.
;
; On exit: A = ??, X & Y are unchanged.

_ROL16      MACRO VLA,RES
      IF VLA != RES
       LDA VLA+0
       ROL A
       STA RES+0
       LDA VLA+1
       ROL A
       STA RES+1
      ELSE
       ROL VLA+0
       ROL VLA+1
      ENDIF
      ENDM

; Perform a left rotation on the 32 bit number at
; location VLA and store the result at location
; RES. If VLA and RES are the same then the
; operation is applied directly to the memory,
; otherwise it is done in the accumulator.
;
; On exit: A = ??, X & Y are unchanged.

_ROL32      MACRO VLA,RES
      IF VLA != RES
       LDA VLA+0
       ROL A
       STA RES+0
       LDA VLA+1
       ROL A
       STA RES+1
       LDA VLA+2
       ROL A
       STA RES+2
       LDA VLA+3
       ROL A
       STA RES+3
      ELSE
       ROL VLA+0
       ROL VLA+1
       ROL VLA+2
       ROL VLA+3
      ENDIF
      ENDM

; Perform an logical shift right on the 16 bit
; number at location VLA and store the result at
; location RES. If VLA and RES are the same then
; the operation is applied directly to the memory
; otherwise it is done in the accumulator.
;
; On exit: A = ??, X & Y are unchanged.

_LSR16      MACRO VLA,RES
      IF VLA != RES
       LDA VLA+1
       LSR A
       STA RES+1
       LDA VLA+0
       ROR A
       STA RES+0
      ELSE
       LSR VLA+1
       ROR VLA+0
      ENDIF
      ENDM

; Perform an logical shift right on the 32 bit
; number at location VLA and store the result at
; location RES. If VLA and RES are the same then
; the operation is applied directly to the memory
; otherwise it is done in the accumulator.
;
; On exit: A = ??, X & Y are unchanged.

_LSR32      MACRO VLA,RES
      IF VLA != RES
       LDA VLA+3
       LSR A
       STA RES+3
       LDA VLA+2
       ROR A
       STA RES+2
       LDA VLA+1
       ROR A
       STA RES+1
       LDA VLA+0
       ROR A
       STA RES+0
      ELSE
       LSR VLA+3
       ROR VLA+2
       ROR VLA+1
       ROR VLA+0
      ENDIF
      ENDM

; Perform a right rotation on the 16 bit number
; at location VLA and store the result at
; location RES. If VLA and RES are the same then
; the operation is applied directly to the memory
; otherwise it is done in the accumulator.
;
; On exit: A = ??, X & Y are unchanged.

_ROR16      MACRO VLA,RES
      IF VLA != RES
       LDA VLA+1
       ROR A
       STA RES+1
       LDA VLA+0
       ROR A
       STA RES+0
      ELSE
       ROR VLA+1
       ROR VLA+0
      ENDIF
      ENDM

; Perform a right rotation on the 32 bit number
; at location VLA and store the result at
; location RES. If VLA and RES are the same then
; the operation is applied directly to the memory
; otherwise it is done in the accumulator.
;
; On exit: A = ??, X & Y are unchanged.

_ROR32      MACRO VLA,RES
      IF VLA != RES
       LDA VLA+3
       ROR A
       STA RES+3
       LDA VLA+2
       ROR A
       STA RES+2
       LDA VLA+1
       ROR A
       STA RES+1
       LDA VLA+0
       ROR A
       STA RES+0
      ELSE
       ROR VLA+3
       ROR VLA+2
       ROR VLA+1
       ROR VLA+0
      ENDIF
      ENDM

      PAGE
;------------------------------------------------
; Arithmetic Operations
;------------------------------------------------

; Increment the 16 bit value at location MEM
; by one.
;
; On exit: A, X & Y are unchanged.

_INC16      MACRO MEM
      INC MEM+0
      BNE _DONE\?
      INC MEM+1
_DONE\?      EQU *
      ENDM

; Increment the 32 bit value at location MEM
; by one.
;
; On exit: A, X & Y are unchanged.

_INC32      MACRO MEM
      INC MEM+0
      BNE _DONE\?
      INC MEM+1
      BNE _DONE\?
      INC MEM+2
      BNE _DONE\?
      INC MEM+3
_DONE\?      EQU *
      ENDM

; Decrement the 16 bit value at location MEM
; by one.
;
; On exit: A = ??, X & Y are unchanged.

_DEC16      MACRO MEM
      LDA MEM+0
      BNE _DONE\?
      DEC MEM+1
_DONE\?      DEC MEM+0
      ENDM

; Decrement the 32 bit value at location MEM
; by one.
;
; On exit: A = ??, X & Y are unchanged.

_DEC32      MACRO MEM
      LDA MEM+0
      BNE _DEC0\?
      LDA MEM+1
      BNE _DEC1\?
      LDA MEM+2
      BNE _DEC2\?
      DEC MEM+3
_DEC2\?      DEC MEM+2
_DEC1\?      DEC MEM+1
_DEC0\?      DEC MEM+0
      ENDM

; Add two 16 bit numbers together and store the
; result in another memory location. RES may be
; the same as either VLA or VLB.
;
; On exit: A = ??, X & Y are unchanged.

_ADD16      MACRO VLA,VLB,RES
      IF VLA != VLB
        CLC
        LDA VLA+0
       ADC VLB+0
       STA RES+0
       LDA VLA+1
       ADC VLB+1
       STA RES+1
      ELSE
       _ASL16 VLA,RES
      ENDIF
      ENDM

; Add two 32 bit numbers together and store the
; result in another memory location. RES may be
; the same as either VLA or VLB.
;
; On exit: A = ??, X & Y are unchanged.

_ADD32      MACRO VLA,VLB,RES
      IF VLA != VLB
       CLC
       LDA VLA+0
       ADC VLB+0
       STA RES+0
       LDA VLA+1
       ADC VLB+1
       STA RES+1
       LDA VLA+2
       ADC VLB+2
       STA RES+2
       LDA VLA+3
       ADC VLB+3
       STA RES+3
      ELSE
       _ASL32 VLA,RES
      ENDIF
      ENDM

; Subtract two 16 bit numbers and store the
; result in another memory location. RES may be
; the same as VLA or VLB.
;
; On exit: A = ??, X & Y are unchanged.

_SUB16      MACRO VLA,VLB,RES
      SEC
      LDA VLA+0
      SBC VLB+0
      STA RES+0
      LDA VLA+1
      SBC VLB+1
      STA RES+1
      ENDM

; Subtract two 32 bit numbers and store the
; result in another memory location. RES may be
; the same as VLA or VLB.
;
; On exit: A = ??, X & Y are unchanged.

_SUB32      MACRO VLA,VLB,RES
      SEC
      LDA VLA+0
      SBC VLB+0
      STA RES+0
      LDA VLA+1
      SBC VLB+1
      STA RES+1
      LDA VLA+2
      SBC VLB+2
      STA RES+2
      LDA VLA+3
      SBC VLB+3
      STA RES+3
      ENDM

; Negate the signed 16 bit number at location VLA
; and stored the result at location RES. RES may
; be the same as VLA.
;
; On exit: A = ??, X & Y are unchanged.

_NEG16      MACRO VLA,RES
      SEC
      LDA #0
      SBC VLA+0
      STA RES+0
      LDA #0
      SBC VLA+1
      STA RES+1
      ENDM

; Negate the signed 32 bit number at location VLA
; and stored the result at location RES. RES may
; be the same as VLA.
;
; On exit: A = ??, X & Y are unchanged.

_NEG32      MACRO VLA,RES
      SEC
      LDA #0
      SBC VLA+0
      STA RES+0
      LDA #0
      SBC VLA+1
      STA RES+1
      LDA #0
      SBC VLA+2
      STA RES+2
      LDA #0
      SBC VLA+3
      STA RES+3
      ENDM

; Calculates the absolute value of signed 16 bit
; number at location VLA and stores it in the RES
; location. Less code is generated if VLA and RES
; are the same location. If 65SC02 instructions
; are available a BRA is used to shorten the
; generated code.
;
; On exit: A = ??, X & Y are unchanged.

_ABS16      MACRO VLA,RES
      BIT VLA+0
      IF VLA != RES
       BPL _MOVE\?
       _NEG16 VLA,RES
       IF __65SC02__
        BRA _DONE\?
       ELSE
        JMP _DONE\?
       ENDIF
_MOVE\?       EQU *
       _XFR16 VLA,RES
      ELSE
       BPL _DONE\?
       _NEG16 VLA,RES
      ENDIF
_DONE\?      EQU *
      ENDM

; Calculates the absolute value of signed 32 bit
; number at location VLA and stores it in the RES
; location. Less code is generated if VLA and RES
; are the same location. If 65SC02 instructions
; are available a BRA is used to shorten the
; generated code.
;
; On exit: A = ??, X & Y are unchanged.

_ABS32      MACRO VLA,RES
      BIT VLA+0
      IF VLA != RES
       BPL _MOVE\?
       _NEG32 VLA,RES
       IF __65SC02__
        BRA _DONE\?
       ELSE
        JMP _DONE\?
       ENDIF
_MOVE\?       EQU *
       _XFR32 VLA,RES
      ELSE
       BPL _DONE\?
       _NEG32 VLA,RES
      ENDIF
_DONE\?      EQU *
      ENDM

; Calculate the 16 bit product of two 16 bit
; unsigned numbers. Any overflow during the
; calculation is lost. The number at location
; VLA is destroyed.
;
; On exit: A = ??, X = $FF, Y is unchanged.

_MUL16      MACRO VLA,VLB,RES
      _CLR16 RES
      LDX #16
_LOOP\?      EQU *
      _ASL16 RES,RES
      _ASL16 VLA,VLA
      BCC _NEXT\?
      _ADD16 VLB,RES,RES
_NEXT\?      DEX
      BPL _LOOP\?
      ENDM

; Calculate the 32 bit product of two 16 bit
; unsigned numbers. The number at location VLA
; is destroyed.
;
; On exit: A = ??, X = $FF, Y is unchanged.

_MUL16X      MACRO VLA,VLB,RES
      _CLR32 RES
      LDX #16
_LOOP\?      EQU *
      _ASL32 RES,RES
      _ASL16 VLA,VLA
      BCC _NEXT\?
      _ADD16 VLB,RES,RES
      BCC _NEXT\?
      _INC16 RES+2
_NEXT\?      EQU *
      DEX
      BPL _LOOP\?
      ENDM

; Calculate the 32 bit product of two 32 bit
; unsigned numbers. Any overflow during the
; calculation is lost. The number at location
; VLA is destroyed.
;
; On exit: A = ??, X = $FF, Y is unchanged.

_MUL32      MACRO VLA,VLB,RES
      _CLR32 RES
      LDX #32
_LOOP\?      EQU *
      _ASL32 RES,RES
      _ASL32 VLA,VLA
      BCC _NEXT\?
      _ADD32 VLB,RES,RES
_NEXT\?      EQU *
      DEX
      BPL _LOOP\?
      ENDM

; These two macros write the code necessary
; to multiply a 16 bit at location VLA by
; a 16 bit constant NUM and store the 16 bit
; result in location RES.
;
; On exit: A = ??, X & Y unchanged.

_MUL16I      MACRO VLA,NUM,RES
      IF NUM = 1
       _XFR16 VLA,RES
      ELSE
       _CLR16 RES
       __MUL16I VLA,NUM,RES
      ENDIF
      ENDM

__MUL16I   MACRO VLA,NUM,RES
       IF NUM & $FFFE
        __MUL16I VLA,(NUM/2),RES
        _ASL16 RES,RES
       ENDIF
       IF NUM & $0001
         _ADD16 VLA,RES,RES
       ENDIF
      ENDM

; Divide the 16 bit number at location VLA
; by the 16 bit number at location VLB
; leaving the 16 bit quotient at QUO and
; the 16 bit remainder in REM. The value in
; location VLA is destroyed.
;
; On exit: A = ??, X = $FF, Y is unchanged.

_DIV16      MACRO VLA,VLB,QUO,REM
      _CLR16 REM
      LDX #16
_LOOP\?      EQU *
      _ASL16 VLA,VLA
      _ROL16 REM,REM
      _SUB16 REM,VLB,REM
      BCS _NEXT\?
      _ADD16 REM,VLB,REM
_NEXT\?      EQU *
      _ROL16 QUO,QUO
      DEX
      BPL _LOOP\?
      ENDM

; Divide the 32 bit number at location VLA
; by the 16 bit number at location VLB
; leaving the 16 bit quotient at QUO and
; the 16 bit remainder in REM. The value in
; location VLA is destroyed.
;
; On exit: A = ??, X = $FF, Y is unchanged.

_DIV16X      MACRO VLA,VLB,QUO,REM
      _CLR16 REM
      LDX #32
_LOOP\?      EQU *
      _ASL32 VLA,VLA
      _ROL16 REM,REM
      _SUB16 REM,VLB,REM
      BCS _NEXT\?
      _ADD16 REM,VLB,REM
_NEXT\?      EQU *
      _ROL16 QUO,QUO
      DEX
      BPL _LOOP\?
      ENDM

; Divide the 32 bit number at location VLA
; by the 32 bit number at location VLB
; leaving the 32 bit quotient at QUO and
; the 32 bit remainder in REM. The value in
; location VLA is destroyed.
;
; On exit: A = ??, X = $FF, Y is unchanged.

_DIV32      MACRO VLA,VLB,QUO,REM
      _CLR32 REM
      LDX #32
_LOOP\?      EQU *
      _ASL32 VLA,VLA
      _ROL32 REM,REM
      _SUB32 REM,VLB,REM
      BCS _NEXT\?
      _ADD32 REM,VLB,REM
_NEXT\?      EQU *
      _ROL32 QUO,QUO
      DEX
      BPL _LOOP\?
      ENDM

      PAGE
;------------------------------------------------
; Comparative Operations
;------------------------------------------------

; Compares two 16 bit values in memory areas VLA
; and VLB. The comparison starts with the most
; significant bytes and returns as soon as a
; difference is detected.
;
; On exit: A = ??, X & Y are unchanged.

_CMP16      MACRO VLA,VLB
      LDA VLA+1
      CMP VLB+1
      BNE _DONE\?
      LDA VLA+0
      CMP VLB+0
_DONE\?      EQU *
      ENDM

; Compares two 32 bit values in memory areas VLA
; and VLB. The comparison starts with the most
; significant bytes and returns as soon as a
; difference is detected.
;
; On exit: A = ??, X & Y are unchanged.

_CMP32      MACRO VLA,VLB
      LDA VLA+3
      CMP VLB+3
      BNE _DONE\?
      LDA VLA+2
      CMP VLB+2
      BNE _DONE\?
      LDA VLA+1
      CMP VLB+1
      BNE _DONE\?
      LDA VLA+0
      CMP VLB+0
_DONE\?      EQU *
      ENDM

      PAGE
;------------------------------------------------
; Memory Operations
;------------------------------------------------

; Transfers a block of memory from one place to
; another by copying the bytes starting at the
; front of the block and going forward. SRC and
; DST are destroyed during the copy.
;
; On exit: A, X & Y = ??.

_MEMFWD      MACRO  SRC,DST,LEN
      LDY #0
      LDX LEN+1
      BEQ _FRAG\?
_PAGE\?      LDA (SRC),Y
      STA (DST),Y
      INY
      BNE _PAGE\?
      INC SRC+1
      INC DST+1
      DEX
      BNE _PAGE\?
_FRAG\?      CPY LEN+0
      BEQ _DONE\?
      LDA (SRC),Y
      STA (DST),Y
      INY
      BNE _FRAG\?
_DONE\?      EQU *
      ENDM

; Transfers a block of memory from one place to
; another by copying the bytes starting at the
; end of the block and going backwards.

_MEMREV      MACRO  SRC,DST,LEN
      NOP
      ENDM

; Tranfers a block of memory from one location to
; another. Depending on the relative positions of
; the blocks an appropriate transfer method is
; used.

_MEMCPY      MACRO  SRC,DST,LEN
      _CMP16 SRC,DST
      BCC _SAFE\?
      _MEMFWD SRC,DST,LEN
      IF __65SC02__
       BRA _DONE\?
      ELSE
       JMP _DONE\?
      ENDIF
_SAFE\?      _MEMREV SRC,DST,LEN
_DONE\?      EQU *
      ENDM

      PAGE
;------------------------------------------------
; String Operations
;------------------------------------------------

; Calculates length of a null terminated string
; by searching for its end. The address of the
; string in STR is destroyed during the search.
;
; On exit: A & Y = ??, X is unchanged.

_STRLEN      MACRO  STR,LEN
      LDY #0
      STY LEN+1
_LOOP\?      LDA (STR),Y
      BEQ _DONE\?
      INY
      BNE _LOOP\?
      INC LEN+1
      INC STR+1
      IF __65SC02__
       BRA _LOOP\?
      ELSE
       JMP _LOOP\?
      ENDIF
_DONE\?      STY LEN+0
      ENDM

; Copies a null terminated string from one memory
; location to another. The source and destination
; addresses are destroyed during the copy process.
;
; On exit: A & Y = ??, X is unchanged.

_STRCPY      MACRO SRC,DST
      LDY #0
_LOOP\?      LDA (SRC),Y
      STA (DST),Y
      BEQ _DONE\?
      INY
      BNE _LOOP\?
      INC SRC+1
      INC DST+1
      IF __65SC02__
       BRA _LOOP\?
      ELSE
       JMP _LOOP\?
      ENDIF
_DONE\?      EQU *
      ENDM

;

_STRCMP      MACRO VLA,VLB
      LDY #0
_LOOP\?      LDA (VLA),Y
      CMP (VLB),Y
      BNE _DONE\?
      LDA (VLA),Y
      BEQ _DONE\?
      INY
      BNE _LOOP\?
      INC VLA+1
      INC VLB+1
      IF __65SC02__
       BRA _LOOP\?
      ELSE
       JMP _LOOP\?
      ENDIF
_DONE\?      EQU *
      ENDM

;

_STRNCMP   MACRO VLA,VLB,LEN
      ENDM

      LIST

Add new attachment

Only authorized users are allowed to upload new attachments.
« This page (revision-1) was last changed on 20-Feb-2010 21:17 by Carsten Strotmann