You are looking at historical revision 27503 of this page. It may differ significantly from its current revision.

• eggs

sixtyfive-oh-two

Introduction

This extension provides an emulator for the 6502 CPU, (including the extended opcodes found in the 65C02 variant of this processor).

Only the pure CPU is emulated, no hardware-interaction model is provided.

The opcode-interpreter is implemented in crunch, and so a C++ compiler must be installed on your system. The interpreter-code is pre-compiled and included in the egg as compiling it takes quite a while. Compiling the C++ code needs crunch.h, so crunch must be installed.

Procedures

[procedure] (make-processor #!key memory registers)

Returns a record structure representing a single 6502 processor. memory} should be an u8vector that is used as RAM, usually of length 65546. {{registers should be an 7 element u8vector, where the elements hold the values of the registers, according to the following table:

AXYPSPC (low byte) PC (high byte)

Index	Register
0
0
0
0
0
0
0

[procedure] (processor? X)

Returns #t if X is a processor record or #f otherwise.

[procedure] (processor-memory P)
[procedure] (processor-memory-set! P U8VECTOR)
[procedure] (processor-registers P)
[procedure] (processor-registers-set! P U8VECTOR)

Accessors for the processor record.

[procedure] (reset! P)

Resets the CPU represented by P by setting A, X, Y to zero, P to #x20, S to #xff and PC to the 16-bit address stored at location #xfffc.

[procedure] (execute! P #!key cycles)

Executes instructions for processor P with the state currently active in the processor record. Execution continues endlessly or after at least cycles CPU cycles have been consumed (instructions always run to completion).

[procedure] (interrupt! P VEC)

Triggers an interrupt for processor P by pushing the PC and P registers, setting the interrupt flag and continuing execution at the address stored at the memory location given in VEC.

Examples

Say you need a fast way of multiplying an 8-bit quantity with 10, then you could do:

(use sixtyfive-oh-two srfi-4 lolevel utils miscmacros)

;; Fast Multiply by 10
;; By Leo Nechaev (leo@ogpi.orsk.ru), 28 October 2000.

; * = $1000
; LDA #18
; JSR MULT10
; L1:
; JMP L1
; MULT10:
; ASL A         ;multiply by 2
; STA TEMP    ;temp store in TEMP
; ASL A        ;again multiply by 2 (*4)
; ASL A        ;again multiply by 2 (*8)
; CLC
; ADC TEMP    ;as result, A = x*8 + x*2
; RTS

(define mult10
  '#${a9 12
      20 08 10
      4c 05 10
      0a
      8d 00 20
      0a
      0a
      18
      6d 00 20
      60})

(define p (make-processor))
(move-memory! mult10 (processor-memory p) (blob-size mult10) 0 #x1000)
(define regs (processor-registers p))
(u8vector-set! regs 5 #x00)			; PC = #x1000
(u8vector-set! regs 6 #x10)
(execute! p cycles: 100)
(pp regs)
(assert (= 180 (u8vector-ref regs 0)))

The sixtyfive-oh-two egg also contains a copy of the FIG Forth interpreter for the 6502. Download the code by entering

 chicken-install -retrieve -test sixtyfive-oh-two

and check out the "test" subdirectory. More examples, the sources for the interpreter and hardware emulation code can be found in the egg SVN repository: http://code.call-cc.org/svn/chicken-eggs/release/4/sixtyfive-oh-two/stuff/ (user: anonymous, password: empty).

Authors

Felix Winkelmann

License

(c)2012 Felix Winkelmann

Available under a 3-clause BSD license.

Version History

0.1

initial release