chickadee » sixtyfive-oh-two

Outdated egg!

This is an egg for CHICKEN 4, the unsupported old release. You're almost certainly looking for the CHICKEN 5 version of this egg, if it exists.

If it does not exist, there may be equivalent functionality provided by another egg; have a look at the egg index. Otherwise, please consider porting this egg to the current version of CHICKEN.



An emulator for the 6502 CPU.

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 the crunch extension must be installed.


make-processor #!key memory registersprocedure

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:

5PC (low byte)
6PC (high byte)
processor? Xprocedure

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

processor-memory Pprocedure
processor-memory-set! P U8VECTORprocedure
processor-registers Pprocedure
processor-registers-set! P U8VECTORprocedure

Accessors for the processor record.

reset! Pprocedure

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.

execute! P #!key cyclesprocedure

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).

interrupt! P VECprocedure

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.


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 (, 28 October 2000.

; * = $1000
; LDA #18
; 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)
; ADC TEMP    ;as result, A = x*8 + x*2

(define mult10
  '#${a9 12
      20 08 10
      4c 05 10
      8d 00 20
      6d 00 20

(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: (user: anonymous, password: empty).


Felix Winkelmann


(c)2012 Felix Winkelmann
Available under a 3-clause BSD license.

Version History

initial release

Contents »